switch tests to using typescript and add type definitions

Author: joeferner

README.md

@@ -9,6 +9,7 @@ Bridge API to connect with existing Java APIs.
 ### Other projects that might be helpful
 
 * [node-java-maven](https://github.com/joeferner/node-java-maven) - manages your node-java classpath by using maven dependency management.
+* [ts-java](https://github.com/RedSeal-co/ts-java) - Create TypeScript declaration files for Java packages.
 
 ## Installation
 

eslint.config.mjs

@@ -1,12 +1,13 @@
 import js from "@eslint/js";
 import globals from "globals";
-import { defineConfig } from "eslint/config";
+import tseslint from "typescript-eslint";
 
-export default defineConfig([
+export default tseslint.config([
+  { ignores: ["build"] },
   {
     files: ["**/*.{js,mjs,cjs}"],
     plugins: { js },
-    extends: ["js/recommended"],
+    extends: [js.configs.recommended],
     languageOptions: { globals: globals.node },
     rules: {
       "no-var": ["error"],
@@ -22,4 +23,43 @@ export default defineConfig([
       ],
     },
   },
+  {
+    extends: [js.configs.recommended, ...tseslint.configs.recommendedTypeChecked],
+    files: ["**/*.{ts,tsx}"],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    plugins: {},
+    rules: {
+      "@typescript-eslint/restrict-template-expressions": [
+        "error",
+        {
+          allowNever: true,
+        },
+      ],
+      "@typescript-eslint/require-await": "off",
+      "@typescript-eslint/no-unsafe-assignment": "off",
+      "@typescript-eslint/no-unsafe-call": "off",
+      "@typescript-eslint/no-unsafe-member-access": "off",
+      "@typescript-eslint/no-unsafe-argument": "off",
+      "@typescript-eslint/no-unsafe-return": "off",
+      "@typescript-eslint/no-redundant-type-constituents": "off",
+      "@typescript-eslint/no-floating-promises": "error",
+      "@typescript-eslint/explicit-member-accessibility": "error",
+      "@typescript-eslint/explicit-function-return-type": "error",
+      "@typescript-eslint/no-unused-vars": [
+        "warn", // or "error"
+        {
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+          caughtErrorsIgnorePattern: "^_",
+        },
+      ],
+    },
+  },
 ]);

java.d.ts

@@ -0,0 +1,74 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// eslint-disable-next-line no-var
+declare var NodeJavaCore: NodeJavaCore.NodeAPI;
+export = NodeJavaCore;
+
+declare namespace NodeJavaCore {
+  type JavaObject = any;
+  type JavaError = Error & { cause?: JavaObject };
+
+  export interface Callback<T> {
+    (err?: Error, result?: T): void;
+  }
+
+  export interface JavaCallback<T> {
+    (err?: JavaError, result?: T): void;
+  }
+
+  interface Promisify {
+    (fn: Function, receiver?: any): Function;
+  }
+
+  interface AsyncOptions {
+    syncSuffix: string;
+    asyncSuffix?: string | undefined;
+    promiseSuffix?: string | undefined;
+    promisify?: Promisify | undefined;
+    ifReadOnlySuffix?: string | undefined;
+  }
+
+  interface ProxyFunctions {
+    [index: string]: Function;
+  }
+
+  interface Java {
+    classpath: string[];
+    options: string[];
+    asyncOptions: AsyncOptions;
+    nativeBindingLocation: string;
+
+    callMethod(instance: any, methodName: string, args: any[], callback: JavaError<any>): void;
+    callMethodSync(instance: any, methodName: string, ...args: any[]): any;
+    callStaticMethod(className: string, methodName: string, ...args: Array<any | JavaError<any>>): void;
+    callStaticMethodSync(className: string, methodName: string, ...args: any[]): any;
+    getStaticFieldValue(className: string, fieldName: string): any;
+    setStaticFieldValue(className: string, fieldName: string, newValue: any): void;
+    instanceOf(javaObject: any, className: string): boolean;
+    registerClient(
+      before: ((cb: Callback<void>) => void) | undefined | null,
+      after?: (cb: Callback<void>) => void
+    ): void;
+    registerClientP(beforeP: (() => Promise<void>) | undefined | null, afterP?: () => Promise<void>): void;
+    ensureJvm(done: Callback<void>): void;
+    ensureJvm(): Promise<void>;
+    isJvmCreated(): boolean;
+
+    newByte(val: number): any;
+    newChar(val: string | number): any;
+    newDouble(val: number): any;
+    newShort(val: number): any;
+    newLong(val: number): any;
+    newFloat(val: number): any;
+    newDouble(val: number): any;
+
+    import(className: string): any;
+    newInstance(className: string, ...args: any[]): void;
+    newInstanceSync(className: string, ...args: any[]): any;
+    newInstanceP(className: string, ...args: any[]): Promise<any>;
+    newArray(className: string, arg: any[]): any;
+    getClassLoader(): any;
+
+    newProxy(interfaceName: string, functions: ProxyFunctions): any;
+  }
+}