motely-wasm 0.0.0

package/types/event.d.ts

@@ -0,0 +1,49 @@
+/** Allows broadcasting events. */
+export interface EventBroadcaster<T extends unknown[]> {
+    /** Notifies attached handlers with specified payload.
+     *  @param args The payload of the notification. */
+    broadcast: (...args: [...T]) => void;
+}
+/** Allows attaching event handlers. */
+export interface EventSubscriber<T extends unknown[]> {
+    /** Attaches specified handler for events emitted by this event instance.
+     *  @param handler The handler to attach. */
+    subscribe: (handler: (...args: [...T]) => void) => string;
+    /** Detaches specified handler from events emitted by this event instance.
+     *  @param handler The handler to detach. */
+    unsubscribe: (handler: (...args: [...T]) => void) => void;
+    /** In case event was broadcast at least once, returns last payload; undefined otherwise. */
+    readonly last?: [...T];
+}
+/** Optional configuration of an event instance. */
+export type EventOptions = {
+    /** Custom warnings handler; by default <code>console.warn</code> is used. */
+    warn?: (message: string) => void;
+};
+/** Allows attaching handlers and broadcasting events. */
+export declare class Event<T extends unknown[]> implements EventBroadcaster<T>, EventSubscriber<T> {
+    private readonly handlers;
+    private readonly warn;
+    private lastArgs?;
+    /** Creates new event instance. */
+    constructor(options?: EventOptions);
+    /** Notifies attached handlers with specified payload.
+     *  @param args The payload of the notification. */
+    broadcast(...args: [...T]): void;
+    /** Attaches specified handler for events emitted by this event instance.
+     *  @param handler The handler to attach. */
+    subscribe(handler: (...args: [...T]) => void): string;
+    /** Detaches specified handler from events emitted by this event instance.
+     *  @param handler The handler to detach. */
+    unsubscribe(handler: (...args: [...T]) => void): void;
+    /** Attaches handler with specified identifier for events emitted by this event instance.
+     *  @param id Identifier of the handler.
+     *  @param handler The handler to attach. */
+    subscribeById(id: string, handler: (...args: [...T]) => void): void;
+    /** Detaches handler with specified identifier from events emitted by this event instance.
+     *  @param id Identifier of the handler. */
+    unsubscribeById(id: string): void;
+    /** In case event was broadcast at least once, returns last payload; undefined otherwise. */
+    get last(): [...T] | undefined;
+    private getOrDefineId;
+}

package/types/exports.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeAPI } from "./modules";
+export declare let exports: unknown;
+export declare function bindExports(runtime: RuntimeAPI, assembly: string): Promise<void>;

package/types/imports.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeAPI } from "./modules";
+export declare function bindImports(runtime: RuntimeAPI): void;

package/types/index.d.ts

@@ -0,0 +1,22 @@
+import { boot, exit, getStatus, BootStatus } from "./boot";
+import { getMain, getNative, getRuntime } from "./modules";
+import { buildConfig } from "./config";
+declare const _default: {
+    boot: typeof boot;
+    exit: typeof exit;
+    getStatus: typeof getStatus;
+    BootStatus: typeof BootStatus;
+    resources: import("./resources").BootResources;
+    /** .NET internal modules and associated utilities. */
+    dotnet: {
+        getMain: typeof getMain;
+        getNative: typeof getNative;
+        getRuntime: typeof getRuntime;
+        buildConfig: typeof buildConfig;
+    };
+};
+export default _default;
+export * from "./event";
+export * from "./bindings.g";
+export type { BootOptions } from "./boot";
+export type { BootResources, BinaryResource } from "./resources";

package/types/instances.d.ts

@@ -0,0 +1,16 @@
+/** Registers specified imported (JS -> C#) interop instance and associates it with unique ID.
+ *  @param instance Interop instance to resolve ID for.
+ *  @return Unique identifier of the registered instance. */
+export declare function registerInstance(instance: object): number;
+/** Resolves registered imported (JS -> C#) interop instance from specified ID.
+ *  @param id Unique identifier of the instance. */
+export declare function getInstance(id: number): object;
+/** Invoked from C# to notify that imported (JS -> C#) interop instance is no longer
+ *  used (eg, was garbage collected) and can be released on JavaScript side as well.
+ *  @param id Unique identifier of the disposed interop instance. */
+export declare function disposeInstance(id: number): void;
+/** Registers specified exported (C# -> JS) instance to invoke dispose on C# side
+ *  when it's collected (finalized) by JavaScript runtime GC.
+ *  @param instance Interop instance to register.
+ *  @param id Unique identifier of the interop instance. */
+export declare function disposeOnFinalize(instance: object, id: number): void;

package/types/modules.d.ts

@@ -0,0 +1,17 @@
+import type { ModuleAPI, MonoConfig, AssetEntry } from "./dotnet.g.d.ts";
+export type * from "./dotnet.g.d.ts";
+export type RuntimeConfig = MonoConfig & {
+    assets?: AssetEntry[];
+};
+/** Fetches main dotnet module (<code>dotnet.js</code>). */
+export declare function getMain(root?: string): Promise<ModuleAPI & {
+    embedded?: boolean;
+}>;
+/** Fetches dotnet native module (<code>dotnet.native.js</code>). */
+export declare function getNative(root?: string): Promise<unknown & {
+    embedded?: boolean;
+}>;
+/** Fetches dotnet runtime module (<code>dotnet.runtime.js</code>). */
+export declare function getRuntime(root?: string): Promise<unknown & {
+    embedded?: boolean;
+}>;

package/types/resources.d.ts

@@ -0,0 +1,18 @@
+/** Resources required to boot .NET runtime. */
+export type BootResources = {
+    /** Compiled .NET WASM runtime module. */
+    readonly wasm: BinaryResource;
+    /** Compiled .NET assemblies. */
+    readonly assemblies: BinaryResource[];
+    /** Name of the entry (main) assembly, with .dll extension. */
+    readonly entryAssemblyName: string;
+};
+/** Boot resource with binary content. */
+export type BinaryResource = {
+    /** Name of the binary file, including extension. */
+    readonly name: string;
+    /** Binary or base64-encoded content of the file; undefined when embedding disabled. */
+    readonly content?: Uint8Array | string;
+};
+/** Resources required to boot .NET runtime. */
+export declare const resources: BootResources;

package/types/resources.g.d.ts

@@ -0,0 +1,3 @@
+import { BootResources } from "./resources";
+declare const _default: BootResources;
+export default _default;