java-bridge 2.1.1 → 2.1.4

package/{ts-src/definitions.ts → dist/ts-src/definitions.d.ts}

@@ -4,45 +4,39 @@
  * may differ if you use a different
  * version of the jvm shared library.
  */
-export enum JavaVersion {
+export declare enum JavaVersion {
     /** Java version 1.1 */
-    VER_1_1 = '1.1',
+    VER_1_1 = "1.1",
     /** Java version 1.2 */
-    VER_1_2 = '1.2',
+    VER_1_2 = "1.2",
     /** Java version 1.4 */
-    VER_1_4 = '1.4',
+    VER_1_4 = "1.4",
     /** Java version 1.6 */
-    VER_1_6 = '1.6',
+    VER_1_6 = "1.6",
     /** Java version 1.8 */
-    VER_1_8 = '1.8',
+    VER_1_8 = "1.8",
     /** Java version 9 */
-    VER_9 = '9',
+    VER_9 = "9",
     /** Java version 10 */
-    VER_10 = '10',
+    VER_10 = "10"
 }
-
-Object.freeze(JavaVersion);
-
 /**
  * Any basic javascript type accepted by this library.
  */
 export declare type BasicType = string | number | boolean | BigInt | null;
-
 /**
  * Any java type accepted by this library, except arrays.
  */
-export type BasicOrJavaType = BasicType | JavaObject | JavaConstructor;
-
+export declare type BasicOrJavaType = BasicType | JavaObject | JavaClass | JavaClassType;
 /**
  * All types accepted by java
  */
-export type JavaType = BasicOrJavaType | BasicOrJavaType[];
-
+export declare type JavaType = BasicOrJavaType | BasicOrJavaType[];
 /**
  * A dummy java object class
  */
-export abstract class JavaObject {}
-
+export declare abstract class JavaObject {
+}
 /**
  * A java class proxy class.
  * This only exists for temporarily storing
@@ -55,90 +49,71 @@ export declare class JavaClassProxy {
     /**
      * The class name
      */
-    public 'class.name': string;
-
+    'class.name': string;
     /**
      * Get the class's constructor
      *
      * @return the java instance proxy constructor
      */
-    public getClassConstructor<
-        T extends JavaClassType = JavaClassType
-    >(): JavaConstructor<T>;
+    getClassConstructor<T extends JavaClassType = UnknownJavaClassType>(): T;
 }
-
-export type JavaClassType = typeof JavaClassInstance;
-
+export declare type JavaClassType = typeof JavaClass;
+export declare type UnknownJavaClassType = typeof UnknownJavaClass;
+export declare type JavaClassConstructorType = typeof JavaClassConstructor;
 /**
- * A java class's constructor
+ * @inheritDoc UnknownJavaClass
  */
-export type JavaConstructor<T extends JavaClassType = JavaClassType> = T &
-    ImportedMembers;
-
+export declare class JavaClassInstance extends UnknownJavaClass {
+}
 /**
- * Any class member imported from java
+ * A java class constructor class
+ *
+ * @see JavaClass
  */
-export interface ImportedMembers {
-    /**
-     * Get the java class instance
-     */
-    get class(): JavaClassInstance;
-
-    /**
-     * Any class member imported.
-     * We'll need to use 'any' as any is callable.
-     * The actual type would be JavaType | ((...args: JavaType[]) => JavaType | Promise<JavaType>)
-     */
-    [member: string]: any;
+export declare class JavaClassConstructor extends JavaClass {
+    constructor(...args: BasicOrJavaType[]);
 }
-
 /**
  * A constructor type.
  */
-export type Constructor<T> = { new (): T };
-
+export declare type Constructor<T> = {
+    new (): T;
+};
 /**
- * The java instance proxy class.
- * This class actually does all the magic.
- * After it is created, this will just be a constructor
- * with all static methods and properties (the accessible ones)
- * stored in it and ready for use. Once the actual instance
- * using the new operator is created, a new
- * java_instance_proxy instance is created, containing
- * the actual java instance (that thing isn't visible though)
- * and all (visible) non-static class member methods and properties.
+ * A class to be extended for custom class definitions.
+ * This does not allow for any methods to be called if not
+ * defined in the class definition.
+ *
+ * ## Example
+ * ```ts
+ * import { importClass } from 'java-bridge';
+ *
+ * declare class PersonClass extends JavaClass {
+ *     public constructor(name: string, age: number);
+ *     public newInstanceAsync(name: string, age: number): Promise<Person>;
+ *
+ *     public getName(): Promise<string>;
+ *     public getNameSync(): string;
+ *     public getAge(): Promise<number>;
+ *     public getAgeSync(): number;
+ * }
+ *
+ * class Person extends importClass<typeof PersonClass>('com.test.Person') {}
+ *
+ * const person = new Person('John', 20);
+ * console.log(person.getNameSync()); // John
+ * console.log(person.getAgeSync()); // 20
+ * ```
  */
-export declare class JavaClassInstance extends JavaObject {
+export declare class JavaClass extends JavaObject {
     /**
-     * The class proxy class instance
-     */
-    public static readonly 'class.proxy': JavaClassProxy;
-
-    /**
-     * Create a new java class instance.
-     * Async version.
-     *
-     * @template T the type of this class as a new instance of this class will be returned
-     * @param args the arguments to create the instance
-     * @return the java_instance_proxy instance
+     * Get the java class instance
      */
-    public static newInstanceAsync(
-        this: never,
-        ...args: BasicOrJavaType[]
-    ): Promise<unknown>;
-    public static newInstanceAsync<T extends JavaClassInstance>(
-        this: Constructor<T>,
-        ...args: BasicOrJavaType[]
-    ): Promise<T>;
-
+    static get class(): UnknownJavaClass;
     /**
-     * Create a new java instance of type
-     * java_instance_proxy["class.proxy.instance"]
-     *
-     * @param args the arguments to create the instance
+     * The class proxy class instance
      */
-    public constructor(...args: BasicOrJavaType[]);
-
+    static readonly 'class.proxy': JavaClassProxy;
     /**
      * Check if this is an instance of another class.
      * Pass either the name of the other class or the class itself
@@ -162,10 +137,7 @@ export declare class JavaClassInstance extends JavaObject {
      * @param other the class to check if this is an instance of
      * @return true if this is instance of `other`
      */
-    public instanceOf<T extends typeof JavaClassInstance>(
-        other: string | T
-    ): boolean;
-
+    instanceOf<T extends JavaClassConstructorType>(other: string | T): boolean;
     /**
      * Default java equals implementation.
      * Async call.
@@ -173,8 +145,7 @@ export declare class JavaClassInstance extends JavaObject {
      * @param o the object to compare this to
      * @returns true if this matches o
      */
-    public equals(o: JavaClassInstance): Promise<boolean>;
-
+    equals(o: JavaClass): Promise<boolean>;
     /**
      * Default java equals implementation.
      * Sync call.
@@ -182,24 +153,51 @@ export declare class JavaClassInstance extends JavaObject {
      * @param o the object to compare this to
      * @returns true if this matches o
      */
-    public equalsSync(o: JavaClassInstance): boolean;
-
+    equalsSync(o: JavaClass): boolean;
     /**
      * Java default toString method.
      * Async call.
      *
      * @returns this as a string
      */
-    public toString(): Promise<string>;
-
+    toString(): Promise<string>;
     /**
      * Java default toString method.
      * Sync call.
      *
      * @returns this as a string
      */
-    public toStringSync(): string;
-
+    toStringSync(): string;
+}
+/**
+ * The java instance proxy class.
+ * This class actually does all the magic.
+ * After it is created, this will just be a constructor
+ * with all static methods and properties (the accessible ones)
+ * stored in it and ready for use. Once the actual instance
+ * using the new operator is created, a new
+ * java_instance_proxy instance is created, containing
+ * the actual java instance (that thing isn't visible though)
+ * and all (visible) non-static class member methods and properties.
+ */
+export declare class UnknownJavaClass extends JavaClass {
+    /**
+     * Create a new java class instance.
+     * Async version.
+     *
+     * @template T the type of this class as a new instance of this class will be returned
+     * @param args the arguments to create the instance
+     * @return the java_instance_proxy instance
+     */
+    static newInstanceAsync(this: never, ...args: BasicOrJavaType[]): Promise<unknown>;
+    static newInstanceAsync<T extends JavaClass>(this: Constructor<T>, ...args: BasicOrJavaType[]): Promise<T>;
+    /**
+     * Create a new java instance of type
+     * java_instance_proxy["class.proxy.instance"]
+     *
+     * @param args the arguments to create the instance
+     */
+    constructor(...args: BasicOrJavaType[]);
     /**
      * Any class member imported.
      * We'll need to use 'any' as any is callable.
@@ -207,4 +205,10 @@ export declare class JavaClassInstance extends JavaObject {
      * Just throwing it out there.
      */
     [member: string]: any;
+    /**
+     * Any static class member imported.
+     * We'll need to use `any` as `any` is callable.
+     * The actual type would be JavaType | ((...args: JavaType[]) => JavaType | Promise<JavaType>)
+     */
+    static [member: string]: any;
 }

package/dist/ts-src/index.d.ts

@@ -0,0 +1,15 @@
+export { JavaVersion, JavaObject, JavaClassInstance, JavaClassProxy, JavaClass, JavaClassConstructor, JavaType, BasicOrJavaType, BasicType, JavaClassType, Constructor, UnknownJavaClassType, JavaClassConstructorType, } from './definitions';
+import type * as internal from '../native';
+/**
+ * A namespace containing any internal type definitions.
+ * Do not actually use anything from this namespace
+ * as it only exports types.
+ */
+export type { internal };
+export * from './java';
+import * as java from './java';
+export default java;
+export { getJavaLibPath } from '../native';
+import TypescriptDefinitionGenerator from './TypescriptDefinitionGenerator';
+export { TypescriptDefinitionGenerator };
+export { ModuleDeclaration, MethodDeclaration, ProgressCallback, } from './TypescriptDefinitionGenerator';

package/{ts-src/java.ts → dist/ts-src/java.d.ts}

@@ -1,30 +1,5 @@
-import {
-    getClassFields,
-    getField,
-    getStaticField,
-    Java,
-    JavaOptions,
-    setField,
-    setStaticField,
-} from '../native';
-import {
-    JavaClassInstance,
-    JavaClassType,
-    JavaConstructor,
-    JavaVersion,
-} from './definitions';
-import { getJavaLibPath, getNativeLibPath } from './nativeLib';
-
-/**
- * The static java instance
- */
-let javaInstance: Java | null = null;
-
-interface ImportedJavaClass {
-    'class.proxy': object;
-    new (...args: any[]): any;
-}
-
+import { Java, JavaOptions } from '../native';
+import { JavaClass, JavaClassConstructorType, JavaVersion, UnknownJavaClassType } from './definitions';
 /**
  * Options for creating the Java VM.
  */
@@ -42,7 +17,6 @@ export interface JVMOptions extends JavaOptions {
      */
     opts?: Array<string> | null;
 }
-
 /**
  * Ensure the java vm is created.
  * If the jvm is already created, this does nothing.
@@ -78,43 +52,7 @@ export interface JVMOptions extends JavaOptions {
  *
  * @param options the options to use when creating the jvm
  */
-export function ensureJvm(options?: JVMOptions): void {
-    if (!javaInstance) {
-        javaInstance = new Java(
-            options?.libPath,
-            options?.version,
-            options?.opts,
-            options,
-            getJavaLibPath(),
-            getNativeLibPath()
-        );
-    }
-}
-
-function defineFields(object: Record<string, any>, getStatic: boolean): void {
-    for (const field of getClassFields(object['class.proxy'], getStatic)) {
-        const getter = (): any =>
-            getStatic
-                ? getStaticField(object, field.name)
-                : getField(object, field.name);
-        if (field.isFinal) {
-            Object.defineProperty(object, field.name, {
-                get: getter,
-                enumerable: true,
-            });
-        } else {
-            Object.defineProperty(object, field.name, {
-                get: getter,
-                set: (value: any) =>
-                    getStatic
-                        ? setStaticField(object, field.name, value)
-                        : setField(object, field.name, value),
-                enumerable: true,
-            });
-        }
-    }
-}
-
+export declare function ensureJvm(options?: JVMOptions): void;
 /**
  * Import a class.
  * Returns the constructor of the class to be created.
@@ -180,47 +118,11 @@ function defineFields(object: Record<string, any>, getStatic: boolean): void {
  * @param classname the name of the class to resolve
  * @return the java class constructor
  */
-export function importClass<T extends JavaClassType = JavaClassType>(
-    classname: string
-): JavaConstructor<T> {
-    ensureJvm();
-    const constructor = javaInstance!.importClass(
-        classname
-    ) as ImportedJavaClass;
-    defineFields(constructor, true);
-
-    constructor.constructor = function (...args: any[]) {
-        const object = new constructor.prototype.constructor(...args);
-        defineFields(object, false);
-
-        return object;
-    };
-
-    return constructor as unknown as JavaConstructor<T>;
-}
-
+export declare function importClass<T extends JavaClassConstructorType = UnknownJavaClassType>(classname: string): T;
 /**
  * @inheritDoc importClass
  */
-export async function importClassAsync<T extends JavaClassType = JavaClassType>(
-    classname: string
-): Promise<JavaConstructor<T>> {
-    ensureJvm();
-    const constructor = (await javaInstance!.importClassAsync(
-        classname
-    )) as ImportedJavaClass;
-    defineFields(constructor, true);
-
-    constructor.constructor = function (...args: any[]) {
-        const object = new constructor.prototype.constructor(...args);
-        defineFields(object, false);
-
-        return object;
-    };
-
-    return constructor as unknown as JavaConstructor<T>;
-}
-
+export declare function importClassAsync<T extends JavaClassConstructorType = UnknownJavaClassType>(classname: string): Promise<T>;
 /**
  * Append a single or multiple jars to the class path.
  *
@@ -248,15 +150,11 @@ export async function importClassAsync<T extends JavaClassType = JavaClassType>(
  *
  * @param path the path(s) to add
  */
-export function appendClasspath(path: string | string[]): void {
-    ensureJvm();
-    javaInstance!.appendClasspath(path);
-}
-
+export declare function appendClasspath(path: string | string[]): void;
 /**
  * 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'.
  *
@@ -287,14 +185,7 @@ export function appendClasspath(path: string | string[]): void {
  * @param other the class or class name to check against
  * @return true if `this_obj` is an instance of `other`
  */
-export function isInstanceOf<T extends typeof JavaClassInstance>(
-    this_obj: JavaClassInstance,
-    other: string | T
-): boolean {
-    ensureJvm();
-    return javaInstance!.isInstanceOf(this_obj, other);
-}
-
+export declare function isInstanceOf<T extends JavaClassConstructorType>(this_obj: JavaClass, other: string | T): boolean;
 /**
  * Methods for altering and querying the class path.
  * @example
@@ -306,25 +197,18 @@ export function isInstanceOf<T extends typeof JavaClassInstance>(
  * assert.equal(classpath.get().length, 1);
  * assert.equal(classpath.get()[0], '/path/to/jar.jar');
  */
-export namespace classpath {
+export declare namespace classpath {
     /**
      * @inheritDoc appendClasspath
      */
-    export function append(path: string | string[]): void {
-        appendClasspath(path);
-    }
-
+    function append(path: string | string[]): void;
     /**
      * Get the loaded jars in the class path
      *
      * @returns a list of the loaded jars
      */
-    export function get(): string[] {
-        ensureJvm();
-        return javaInstance!.loadedJars;
-    }
+    function get(): string[];
 }
-
 /**
  * A callback for any output redirected from stdout/stderr from the java process.
  *
@@ -332,8 +216,7 @@ export namespace classpath {
  *            This is null if the output was valid. This will probably never be set.
  * @param data the data that was converted. This is unset if <code>err</code> is set.
  */
-export type StdoutCallback = (err: Error | null, data?: string) => void;
-
+export declare type StdoutCallback = (err: Error | null, data?: string) => void;
 /**
  * The class guarding the stdout redirect.
  * Keep this instance in scope to not lose the redirect.
@@ -381,7 +264,6 @@ export interface StdoutRedirectGuard {
      * @param callback the callback
      */
     on(event: 'stdout' | 'stderr', callback: StdoutCallback | null): void;
-
     /**
      * Reset this <code>StdoutRedirectGuard</code> instance.
      * After this call, the stdout/stderr will no longer
@@ -390,7 +272,6 @@ export interface StdoutRedirectGuard {
      */
     reset(): void;
 }
-
 /**
  * A namespace containing methods for redirecting the stdout/stderr of the java process.
  *
@@ -398,7 +279,7 @@ export interface StdoutRedirectGuard {
  * * {@link StdoutRedirectGuard}
  * * {@link stdout.enableRedirect}
  */
-export namespace stdout {
+export declare namespace stdout {
     /**
      * Enable stdout/stderr redirection.
      *
@@ -452,15 +333,8 @@ export namespace stdout {
      * @param stderr the callback to be called when stderr is received
      * @returns a <code>StdoutRedirectGuard</code> instance. Keep this instance in scope to not lose the redirect.
      */
-    export function enableRedirect(
-        stdout?: StdoutCallback | null,
-        stderr?: StdoutCallback | null
-    ): StdoutRedirectGuard {
-        ensureJvm();
-        return javaInstance!.setStdoutCallbacks(stdout, stderr);
-    }
+    function enableRedirect(stdout?: StdoutCallback | null, stderr?: StdoutCallback | null): StdoutRedirectGuard;
 }
-
 /**
  * The class for implementing java interfaces.
  * Keep this instance in scope to not destroy the java object.
@@ -505,7 +379,6 @@ export interface JavaInterfaceProxy {
      */
     reset(): void;
 }
-
 /**
  * An interface proxy method.
  * Any arguments passed to this method are values converted from java values.
@@ -514,11 +387,7 @@ export interface JavaInterfaceProxy {
  * @param args the arguments passed from the java process
  * @return the value to pass back to the java process
  */
-export type ProxyMethod = (...args: any[]) => any;
-type InternalProxyRecord = Parameters<
-    typeof Java.prototype.createInterfaceProxy
->[1];
-
+export declare type ProxyMethod = (...args: any[]) => any;
 /**
  * Create a new java interface proxy.
  * This allows you to implement java interfaces in javascript.
@@ -626,46 +495,9 @@ type InternalProxyRecord = Parameters<
  * @param methods the methods to implement.
  * @returns a proxy class to pass back to the java process
  */
-export function newProxy(
-    interfaceName: string,
-    methods: Record<string, ProxyMethod>
-): JavaInterfaceProxy {
-    ensureJvm();
-    const proxyMethods: InternalProxyRecord = Object.create(null);
-
-    for (const [name, method] of Object.entries(methods)) {
-        proxyMethods[name] = (
-            err: null | Error,
-            callback: (err: Error | null, data?: any | null) => void,
-            ...args: any[]
-        ): void => {
-            if (err) {
-                throw err;
-            }
-
-            try {
-                const res = method(...args);
-                callback(null, res);
-            } catch (e: any) {
-                if (e instanceof Error) {
-                    callback(e);
-                } else {
-                    callback(new Error(e.toString()));
-                }
-            }
-        };
-    }
-
-    return javaInstance!.createInterfaceProxy(
-        interfaceName,
-        proxyMethods
-    ) as JavaInterfaceProxy;
-}
-
+export declare function newProxy(interfaceName: string, methods: Record<string, ProxyMethod>): JavaInterfaceProxy;
 /**
  * Get the static java instance.
  * This has no real use, all important methods are exported explicitly.
  */
-export function getJavaInstance(): Java | null {
-    return javaInstance;
-}
+export declare function getJavaInstance(): Java | null;

package/dist/ts-src/nativeLib.d.ts

@@ -0,0 +1,2 @@
+export declare function getNativeLibPath(): string;
+export declare function getJavaLibPath(): string;

package/dist/ts-src/scripts/cli.d.ts

@@ -0,0 +1 @@
+export {};