java-bridge 2.1.1 → 2.1.4

package/README.md

@@ -249,3 +249,40 @@ Options:
 -   The classpath argument can be supplied multiple times to add multiple jars to the classpath
 -   Multiple class names can be supplied to generate definitions for multiple classes
 -   The generated typescript files will automatically import all classes once the module is loaded.
+
+### Examples
+
+#### Generate definitions for a single class
+
+Generate definitions for the `java.lang.String` class and all its referenced classes and save them to `./project`:
+
+```bash
+java-ts-gen ./project java.lang.String
+```
+
+This will create a directory called `java` containing the definitions for the `java.lang.String` class and all its
+dependencies all inside subdirectories. The `java.lang.String` class will be saved to `./project/java/lang/String.ts`.
+Thus, the folder structure of `project` will look something like this:
+
+```
+.
+├── ...
+├── java
+│   ├── lang
+│   │   ├── String.ts
+│   │   ├── Object.ts
+│   │   └── ...
+│   ├── util
+│   │   └── ...
+│   └── ...
+└── ...
+```
+
+#### Generate definitions for multiple classes
+
+Generate definitions for the `java.lang.String` and `java.util.ArrayList` classes and all of their dependencies
+and save them to `./project`:
+
+```bash
+java-ts-gen ./project java.lang.String java.util.ArrayList
+```

package/dist/index.dev.min.js

@@ -285,6 +285,372 @@ module.exports.StdoutRedirect = StdoutRedirect
 module.exports.getJavaLibPath = getJavaLibPath
 
 
+/***/ }),
+
+/***/ "./ts-src/TypescriptDefinitionGenerator.ts":
+/*!*************************************************!*\
+  !*** ./ts-src/TypescriptDefinitionGenerator.ts ***!
+  \*************************************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const typescript_1 = __importStar(__webpack_require__(/*! typescript */ "typescript"));
+const _1 = __webpack_require__(/*! ./. */ "./ts-src/index.ts");
+const fs_1 = __importDefault(__webpack_require__(/*! fs */ "fs"));
+const path_1 = __importDefault(__webpack_require__(/*! path */ "path"));
+const sourceFile = typescript_1.default.createSourceFile('source.ts', '', typescript_1.default.ScriptTarget.Latest, false, typescript_1.default.ScriptKind.TS);
+/**
+ * A class to generate typescript definitions for java classes.
+ * Converts the given class and all of its dependencies to typescript.
+ *
+ * ## Example
+ * ```ts
+ * import { TypescriptDefinitionGenerator } from 'java-bridge';
+ *
+ * const generator = new TypescriptDefinitionGenerator('java.lang.String');
+ * // Generate the typescript definitions
+ * const definitions = await generator.generate();
+ *
+ * // Save the definitions to a directory
+ * await TypescriptDefinitionGenerator.save(definitions, './project');
+ * ```
+ */
+class TypescriptDefinitionGenerator {
+    /**
+     * Create a new `TypescriptDefinitionGenerator` instance
+     *
+     * @param classname the fully-qualified name of the class to generate a typescript definition for
+     * @param progressCallback a callback method to be called every time a java class is
+     *                         converted to typescript
+     * @param resolvedImports a list of imports that have already been resolved.
+     *                        This is used to prevent converting a class multiple times
+     */
+    constructor(classname, progressCallback = null, resolvedImports = []) {
+        this.classname = classname;
+        this.progressCallback = progressCallback;
+        this.resolvedImports = resolvedImports;
+        this.usesBasicOrJavaType = false;
+        this.additionalImports = [];
+        this.importsToResolve = [];
+    }
+    static async convertMethods(methods) {
+        const Modifier = await (0, _1.importClassAsync)('java.lang.reflect.Modifier');
+        const result = {};
+        for (const method of methods) {
+            const modifiers = await method.getModifiers();
+            if (await Modifier.isPublic(modifiers)) {
+                const name = await method.getName();
+                const returnType = await method.getReturnType();
+                const parameterTypes = await method.getParameterTypes();
+                const data = {
+                    returnType: await returnType.getTypeName(),
+                    parameters: await Promise.all(parameterTypes.map((p) => p.getTypeName())),
+                    isStatic: await Modifier.isStatic(modifiers),
+                };
+                if (Object.hasOwn(result, name)) {
+                    result[name].push(data);
+                }
+                else {
+                    result[name] = [data];
+                }
+            }
+        }
+        return result;
+    }
+    async convertConstructors(constructors) {
+        const Modifier = await (0, _1.importClassAsync)('java.lang.reflect.Modifier');
+        const types = [];
+        for (const constructor of constructors) {
+            const modifiers = await constructor.getModifiers();
+            if (await Modifier.isPublic(modifiers)) {
+                const parameterTypes = await constructor.getParameterTypes();
+                types.push(await Promise.all(parameterTypes.map((p) => p.getTypeName())));
+            }
+        }
+        const tsConstructors = types.map((t, i) => {
+            const params = t.map(this.convertParameter.bind(this));
+            let declaration = typescript_1.default.factory.createConstructorDeclaration([typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.PublicKeyword)], params, undefined);
+            if (i === 0) {
+                declaration = typescript_1.default.addSyntheticLeadingComment(declaration, typescript_1.default.SyntaxKind.SingleLineCommentTrivia, ` ================== Constructors ==================`, true);
+            }
+            if (t.length > 0) {
+                declaration = typescript_1.default.addSyntheticLeadingComment(declaration, typescript_1.default.SyntaxKind.MultiLineCommentTrivia, '*\n' +
+                    t
+                        .map((p, i) => ` * @param var${i} original type: '${p}'\n`)
+                        .join('') +
+                    ' ', true);
+            }
+            return declaration;
+        });
+        const newInstanceMethods = types.map((t, i) => {
+            return this.createMethod({
+                returnType: this.classname,
+                parameters: t,
+                isStatic: true,
+            }, 'newInstance', i, false);
+        });
+        return [...newInstanceMethods, ...tsConstructors];
+    }
+    javaTypeToTypescriptType(javaType, isParam) {
+        switch (javaType) {
+            case 'byte[]':
+            case 'java.lang.Byte[]':
+                return typescript_1.default.factory.createTypeReferenceNode('Buffer');
+        }
+        if (javaType.endsWith('[]')) {
+            return typescript_1.default.factory.createArrayTypeNode(this.javaTypeToTypescriptType(javaType.substring(0, javaType.length - 2), isParam));
+        }
+        switch (javaType) {
+            case 'int':
+            case 'java.lang.Integer':
+            case 'long':
+            case 'java.lang.Long':
+            case 'float':
+            case 'java.lang.Float':
+            case 'double':
+            case 'java.lang.Double':
+            case 'byte':
+            case 'java.lang.Byte':
+            case 'short':
+            case 'java.lang.Short':
+                return typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NumberKeyword);
+            case 'char':
+            case 'java.lang.Character':
+            case 'java.lang.String':
+                return typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword);
+            case 'boolean':
+            case 'java.lang.Boolean':
+                return typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.BooleanKeyword);
+            case 'void':
+            case 'java.lang.Void':
+                return typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.VoidKeyword);
+            case 'java.lang.Object':
+                this.usesBasicOrJavaType = true;
+                return typescript_1.default.factory.createTypeReferenceNode('BasicOrJavaType');
+            default:
+                if (!this.resolvedImports.includes(javaType)) {
+                    this.additionalImports.push(javaType);
+                }
+                this.importsToResolve.push(javaType);
+                const isSelf = javaType === this.classname && isParam;
+                return typescript_1.default.factory.createTypeReferenceNode(javaType === this.classname
+                    ? javaType.substring(javaType.lastIndexOf('.') + 1) +
+                        (isSelf ? 'Class' : '')
+                    : javaType.replaceAll('.', '_'));
+        }
+    }
+    convertParameter(param, index) {
+        const name = 'var' + index;
+        const type = this.javaTypeToTypescriptType(param, true);
+        return typescript_1.default.factory.createParameterDeclaration(undefined, undefined, name, undefined, type);
+    }
+    convertParameters(params) {
+        return params.parameters.map(this.convertParameter.bind(this));
+    }
+    static createMethodComment(declaration) {
+        return ('*\n' +
+            declaration.parameters
+                .map((p, i) => ` * @param var${i} original type: '${p}'\n`)
+                .join('') +
+            ` * @return original return type: '${declaration.returnType}'\n `);
+    }
+    createMethod(m, name, i, isSync) {
+        const publicMod = typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.PublicKeyword);
+        const staticMod = typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.StaticKeyword);
+        const modifiers = [publicMod];
+        if (m.isStatic) {
+            modifiers.push(staticMod);
+        }
+        let returnType = this.javaTypeToTypescriptType(m.returnType, false);
+        if (!isSync) {
+            returnType = typescript_1.default.factory.createTypeReferenceNode(typescript_1.default.factory.createIdentifier('Promise'), [returnType]);
+        }
+        let declaration = typescript_1.default.factory.createMethodDeclaration(modifiers, undefined, name + (isSync ? 'Sync' : ''), undefined, undefined, this.convertParameters(m), returnType, undefined);
+        if (i === 0) {
+            declaration = typescript_1.default.addSyntheticLeadingComment(declaration, typescript_1.default.SyntaxKind.SingleLineCommentTrivia, ` ================== Method ${name} ==================`, true);
+        }
+        return typescript_1.default.addSyntheticLeadingComment(declaration, typescript_1.default.SyntaxKind.MultiLineCommentTrivia, TypescriptDefinitionGenerator.createMethodComment(m), true);
+    }
+    convertMethod(method, name) {
+        const res = [];
+        for (let i = 0; i < method.length; i++) {
+            const m = method[i];
+            res.push(this.createMethod(m, name, i, false), this.createMethod(m, name, i, true));
+        }
+        return res;
+    }
+    getAdditionalImports() {
+        const getPath = (i) => {
+            const thisSplit = this.classname.split('.');
+            const importSplit = i.split('.');
+            for (let j = 0; j < thisSplit.length; j++) {
+                if (importSplit[j] === thisSplit[j]) {
+                    thisSplit[j] = null;
+                    importSplit[j] = null;
+                }
+                else {
+                    break;
+                }
+            }
+            return ('./' +
+                thisSplit
+                    .filter((e) => !!e)
+                    .map(() => '')
+                    .join('../') +
+                importSplit.filter((e) => !!e).join('/'));
+        };
+        const unique = (value, index, self) => {
+            return self.indexOf(value) === index;
+        };
+        return this.importsToResolve
+            .filter((i) => i != this.classname)
+            .filter(unique)
+            .map((i) => typescript_1.default.factory.createImportDeclaration(undefined, typescript_1.default.factory.createImportClause(false, undefined, typescript_1.default.factory.createNamedImports([
+            typescript_1.default.factory.createImportSpecifier(false, typescript_1.default.factory.createIdentifier(i.substring(i.lastIndexOf('.') + 1)), typescript_1.default.factory.createIdentifier(i.replaceAll('.', '_'))),
+        ])), typescript_1.default.factory.createStringLiteral(getPath(i))));
+    }
+    getImports() {
+        const importElements = [
+            typescript_1.default.factory.createImportSpecifier(false, undefined, typescript_1.default.factory.createIdentifier('importClass')),
+            typescript_1.default.factory.createImportSpecifier(false, undefined, typescript_1.default.factory.createIdentifier('JavaClass')),
+        ];
+        if (this.usesBasicOrJavaType) {
+            importElements.push(typescript_1.default.factory.createImportSpecifier(false, undefined, typescript_1.default.factory.createIdentifier('BasicOrJavaType')));
+        }
+        const imports = typescript_1.default.factory.createNamedImports(importElements);
+        return typescript_1.default.factory.createImportDeclaration(undefined, typescript_1.default.factory.createImportClause(false, undefined, imports), typescript_1.default.factory.createStringLiteral('java-bridge'));
+    }
+    getExportStatement(simpleName) {
+        const statement = typescript_1.default.factory.createClassDeclaration([typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword)], simpleName, undefined, [
+            typescript_1.default.factory.createHeritageClause(typescript_1.default.SyntaxKind.ExtendsKeyword, [
+                typescript_1.default.factory.createExpressionWithTypeArguments(typescript_1.default.factory.createIdentifier(`importClass<typeof ${simpleName}Class>("${this.classname}")`), undefined),
+            ]),
+        ], []);
+        return [
+            typescript_1.default.addSyntheticLeadingComment(statement, typescript_1.SyntaxKind.MultiLineCommentTrivia, `*\n * Class ${this.classname}.\n *\n` +
+                ' * This actually imports the java class for further use.\n' +
+                ` * The class ${simpleName}Class only defines types, this is the class you should actually import.\n` +
+                ' * Please note that this statement imports the underlying java class at runtime, which may take a while.\n' +
+                ' * This was generated by java-bridge.\n * You should probably not edit this.\n ', true),
+            typescript_1.default.factory.createExportDefault(typescript_1.default.factory.createIdentifier(simpleName)),
+        ];
+    }
+    getText(nodes) {
+        return nodes
+            .map((n) => (n &&
+            typescript_1.default
+                .createPrinter({ newLine: typescript_1.default.NewLineKind.LineFeed })
+                .printNode(typescript_1.default.EmitHint.Unspecified, n, sourceFile)) ||
+            '')
+            .join('\n');
+    }
+    /**
+     * Generates the typescript definition for the given class.
+     *
+     * @returns the generated typescript definitions
+     */
+    async generate() {
+        if (this.resolvedImports.includes(this.classname)) {
+            return [];
+        }
+        this.resolvedImports.push(this.classname);
+        if (this.progressCallback) {
+            this.progressCallback(this.classname);
+        }
+        const Class = await (0, _1.importClassAsync)(this.classname);
+        const cls = Class.class;
+        const simpleName = this.classname.substring(this.classname.lastIndexOf('.') + 1);
+        const methods = await cls.getDeclaredMethods();
+        const classMembers = [];
+        const convertedMethods = await TypescriptDefinitionGenerator.convertMethods(methods);
+        for (const key of Object.keys(convertedMethods)) {
+            const m = convertedMethods[key];
+            classMembers.push(...this.convertMethod(m, key));
+        }
+        const constructors = await cls.getDeclaredConstructors();
+        const convertedConstructors = await this.convertConstructors(constructors);
+        classMembers.push(...convertedConstructors);
+        let tsClass = typescript_1.default.factory.createClassDeclaration([
+            typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword),
+            typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.DeclareKeyword),
+        ], simpleName + 'Class', undefined, [
+            typescript_1.default.factory.createHeritageClause(typescript_1.default.SyntaxKind.ExtendsKeyword, [
+                typescript_1.default.factory.createExpressionWithTypeArguments(typescript_1.default.factory.createIdentifier('JavaClass'), undefined),
+            ]),
+        ], classMembers);
+        tsClass = typescript_1.default.addSyntheticLeadingComment(tsClass, typescript_1.default.SyntaxKind.MultiLineCommentTrivia, `*\n * This class just defines types, you should import ${simpleName} instead of this.\n` +
+            ' * This was generated by java-bridge.\n * You should probably not edit this.\n ', true);
+        const sourceText = this.getText([
+            this.getImports(),
+            ...this.getAdditionalImports(),
+            null,
+            tsClass,
+            null,
+            ...this.getExportStatement(simpleName),
+        ]);
+        const res = [];
+        for (const imported of this.additionalImports) {
+            const generator = new TypescriptDefinitionGenerator(imported, this.progressCallback, this.resolvedImports);
+            const generated = await generator.generate();
+            res.push(...generated);
+        }
+        res.push({
+            name: this.classname,
+            contents: sourceText,
+        });
+        return res;
+    }
+    /**
+     * Save the converted classes to the given directory.
+     *
+     * @param declarations the declarations to save
+     * @param sourceDir the directory to save the files to
+     */
+    static async save(declarations, sourceDir) {
+        for (const declaration of declarations) {
+            const p = declaration.name.split('.');
+            p[p.length - 1] = p[p.length - 1] + '.ts';
+            const filePath = path_1.default.join(sourceDir, ...p);
+            await fs_1.default.promises.mkdir(path_1.default.dirname(filePath), {
+                recursive: true,
+            });
+            await fs_1.default.promises.writeFile(filePath, declaration.contents, {
+                encoding: 'utf8',
+            });
+        }
+    }
+}
+exports["default"] = TypescriptDefinitionGenerator;
+
+
 /***/ }),
 
 /***/ "./ts-src/definitions.ts":
@@ -365,18 +731,25 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.getJavaLibPath = exports.JavaClassProxy = exports.JavaClassInstance = exports.JavaObject = exports.JavaVersion = void 0;
+exports.TypescriptDefinitionGenerator = exports.getJavaLibPath = exports.JavaClassConstructor = exports.JavaClass = exports.JavaClassProxy = exports.JavaClassInstance = exports.JavaObject = exports.JavaVersion = void 0;
 var definitions_1 = __webpack_require__(/*! ./definitions */ "./ts-src/definitions.ts");
 Object.defineProperty(exports, "JavaVersion", ({ enumerable: true, get: function () { return definitions_1.JavaVersion; } }));
 Object.defineProperty(exports, "JavaObject", ({ enumerable: true, get: function () { return definitions_1.JavaObject; } }));
 Object.defineProperty(exports, "JavaClassInstance", ({ enumerable: true, get: function () { return definitions_1.JavaClassInstance; } }));
 Object.defineProperty(exports, "JavaClassProxy", ({ enumerable: true, get: function () { return definitions_1.JavaClassProxy; } }));
+Object.defineProperty(exports, "JavaClass", ({ enumerable: true, get: function () { return definitions_1.JavaClass; } }));
+Object.defineProperty(exports, "JavaClassConstructor", ({ enumerable: true, get: function () { return definitions_1.JavaClassConstructor; } }));
 __exportStar(__webpack_require__(/*! ./java */ "./ts-src/java.ts"), exports);
 const java = __importStar(__webpack_require__(/*! ./java */ "./ts-src/java.ts"));
 exports["default"] = java;
 var native_1 = __webpack_require__(/*! ../native */ "./native.js");
 Object.defineProperty(exports, "getJavaLibPath", ({ enumerable: true, get: function () { return native_1.getJavaLibPath; } }));
+const TypescriptDefinitionGenerator_1 = __importDefault(__webpack_require__(/*! ./TypescriptDefinitionGenerator */ "./ts-src/TypescriptDefinitionGenerator.ts"));
+exports.TypescriptDefinitionGenerator = TypescriptDefinitionGenerator_1.default;
 
 
 /***/ }),
@@ -587,7 +960,7 @@ exports.appendClasspath = appendClasspath;
 /**
  * Check if `this_obj` is instance of `other`.
  * This uses the native java `instanceof` operator.
- * You may want to use this if {@link JavaClassInstance.instanceOf}
+ * You may want to use this if {@link JavaClass.instanceOf}
  * is overridden, as that method itself does not override
  * any method defined in the specific java class named 'instanceOf'.
  *
@@ -1018,6 +1391,17 @@ module.exports = require("glob");
 
 /***/ }),
 
+/***/ "typescript":
+/*!*****************************!*\
+  !*** external "typescript" ***!
+  \*****************************/
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("typescript");
+
+/***/ }),
+
 /***/ "fs":
 /*!*********************!*\
   !*** external "fs" ***!