java-bridge 2.1.1 → 2.1.4

package/ts-src/nativeLib.ts

@@ -1,86 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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();