java-bridge 2.1.0-beta.1

package/ts-src/nativeLib.ts

@@ -0,0 +1,86 @@
+import path from 'path';
+import fs, { readFileSync } from 'fs';
+import glob from 'glob';
+
+const { platform, arch } = process;
+
+function getModule(base: string): string {
+    const local = path.join(__dirname, base + '.node');
+
+    if (fs.existsSync(local)) {
+        return local;
+    } else {
+        const module = base.replaceAll('.', '-').replace('java', 'java-bridge');
+        // @ts-ignore
+        if (__non_webpack_require__ && __non_webpack_require__.resolve) {
+            // @ts-ignore
+            return __non_webpack_require__.resolve(module);
+        } else {
+            return require.resolve(module);
+        }
+    }
+}
+
+function UnsupportedPlatform(): Error {
+    return new Error(`Unsupported platform: ${platform} ${arch}`);
+}
+
+function isMusl() {
+    // For Node 10
+    if (!process.report || typeof process.report.getReport !== 'function') {
+        try {
+            return readFileSync('/usr/bin/ldd', 'utf8').includes('musl');
+        } catch (e) {
+            return true;
+        }
+    } else {
+        const { glibcVersionRuntime } = (process.report.getReport() as any)
+            .header;
+        return !glibcVersionRuntime;
+    }
+}
+
+export function getNativeLibPath(): string {
+    switch (platform) {
+        case 'android':
+            switch (arch) {
+                case 'arm64':
+                    return getModule('java.android-arm64');
+                case 'arm':
+                    return getModule('java.android-arm-eabi');
+                default:
+                    throw UnsupportedPlatform();
+            }
+        case 'win32':
+            return getModule(`java.win32-${arch}-msvc`);
+        case 'darwin':
+            return getModule(`java.darwin-${arch}`);
+        case 'freebsd':
+            return getModule(`java.freebsd-${arch}`);
+        case 'linux':
+            switch (arch) {
+                case 'x64':
+                case 'arm64':
+                    return getModule(
+                        `java.linux-${arch}-${isMusl() ? 'musl' : 'gnu'}`
+                    );
+                case 'arm':
+                    return getModule('java.linux-arm-gnueabihf');
+                default:
+                    throw UnsupportedPlatform();
+            }
+        default:
+            throw UnsupportedPlatform();
+    }
+}
+
+export function getJavaLibPath(): string {
+    const dir = path.join(__dirname, '..', 'java-src', 'build', 'libs');
+    let files = glob.sync('*.jar', { cwd: dir });
+
+    if (files.length === 0) {
+        throw new Error(`No java lib found in ${dir}`);
+    } else {
+        return path.join(dir, files[0]);
+    }
+}

package/ts-src/scripts/cli.ts

@@ -0,0 +1,142 @@
+import yargs from 'yargs';
+import { performance } from 'perf_hooks';
+import path from 'path';
+import java from '..';
+import { version } from '../../package.json';
+
+interface Args {
+    classnames: string[];
+    output: string;
+    classpath?: string | string[];
+}
+
+type YargsHandler<T> = (args: yargs.ArgumentsCamelCase<T>) => Promise<void>;
+
+const importOra = (): Promise<typeof import('ora').default> =>
+    eval("import('ora').then(ora => ora.default)");
+const importChalk = (): Promise<typeof import('chalk').default> =>
+    eval("import('chalk').then(chalk => chalk.default)");
+
+const builder: yargs.BuilderCallback<{}, Args> = (command) => {
+    command.positional('classnames', {
+        describe: 'The fully qualified class name(s) to convert',
+        type: 'string',
+    });
+
+    command.positional('output', {
+        describe: 'The output file',
+        type: 'string',
+    });
+
+    command.option('classpath', {
+        alias: 'cp',
+        type: 'string',
+        describe: 'The classpath to use',
+    });
+};
+
+const handler: YargsHandler<Args> = async ({
+    classnames,
+    output,
+    classpath,
+}) => {
+    try {
+        const startTime = performance.now();
+
+        if (classpath) {
+            java.classpath.append(classpath);
+        }
+
+        const chalk = await importChalk();
+        const ora = await importOra();
+
+        console.log(
+            `Starting ${chalk.cyanBright('java-bridge')} ${chalk.greenBright(
+                'v' + version
+            )} Java definition generator`
+        );
+
+        const javaInstance = java.getJavaInstance()!;
+        const loadedJars = java.classpath.get();
+        if (loadedJars.length > 0) {
+            console.log(
+                `Started JVM with version ${chalk.cyanBright(
+                    javaInstance.version
+                )} and classpath '${loadedJars
+                    .map((j) => chalk.cyanBright(j))
+                    .join(';')}'`
+            );
+        }
+
+        console.log(
+            `Converting classes ${classnames
+                .map((c) => chalk.magentaBright(c))
+                .join(
+                    ', '
+                )} to typescript and saving result to ${chalk.cyanBright(
+                path.normalize(output)
+            )}`
+        );
+
+        const spinner = ora().start();
+
+        const resolvedImports: string[] = [];
+        let resolvedCounter: number = 0;
+        let numResolved: number = 0;
+
+        let approximateTimeElapsed: number = 0;
+        let lastClassResolved: string = '';
+        const timeElapsedInterval = setInterval(() => {
+            approximateTimeElapsed += 1;
+            setText();
+        }, 1000);
+
+        const setText = () => {
+            spinner.text = chalk.gray(
+                `Elapsed time: ${chalk.yellow(
+                    approximateTimeElapsed
+                )} seconds ${chalk.white('|')} Converted ${chalk.cyanBright(
+                    resolvedCounter
+                )} classes ${chalk.white(
+                    '|'
+                )} Converting class ${chalk.magentaBright(lastClassResolved)}`
+            );
+        };
+
+        const TypescriptDefinitionGenerator = (
+            await import('../TypescriptDefinitionGenerator')
+        ).default;
+
+        for (const classname of classnames) {
+            const generator = new TypescriptDefinitionGenerator(
+                classname,
+                (name) => {
+                    lastClassResolved = name;
+                    resolvedCounter++;
+                    setText();
+                },
+                resolvedImports
+            );
+            const generated = await generator.generate();
+            numResolved += generated.length;
+
+            spinner.text = 'saving results';
+            await TypescriptDefinitionGenerator.save(generated, output);
+        }
+
+        clearInterval(timeElapsedInterval);
+        const timeElapsed = ((performance.now() - startTime) / 1000).toFixed(1);
+        spinner.succeed(
+            `Success - Converted ${chalk.blueBright(
+                numResolved
+            )} classes in ${chalk.blueBright(timeElapsed)} seconds`
+        );
+    } catch (e) {
+        console.error(e);
+        process.exit(1);
+    }
+};
+
+yargs
+    .command<Args>('* <output> <classnames..>', false, builder, handler)
+    .parse();