@tailwindcss/oxide-wasm32-wasi 0.0.0-insiders.bd9cf92 → 0.0.0-insiders.bdcd708

package/node_modules/@emnapi/core/dist/emnapi-core.cjs.min.d.ts

@@ -30,6 +30,30 @@ export declare interface ChildThreadOptions extends BaseOptions {
     postMessage?: (data: any) => void;
 }
 
+/** @public */
+export declare interface CleanupThreadPayload {
+    tid: number;
+}
+
+/** @public */
+export declare interface CommandInfo<T extends CommandType> {
+    type: T;
+    payload: CommandPayloadMap[T];
+}
+
+/** @public */
+export declare interface CommandPayloadMap {
+    load: LoadPayload;
+    loaded: LoadedPayload;
+    start: StartPayload;
+    'cleanup-thread': CleanupThreadPayload;
+    'terminate-all-threads': TerminateAllThreadsPayload;
+    'spawn-thread': SpawnThreadPayload;
+}
+
+/** @public */
+export declare type CommandType = keyof CommandPayloadMap;
+
 /** @public */
 export declare function createInstanceProxy(instance: WebAssembly.Instance, memory?: WebAssembly.Memory | (() => WebAssembly.Memory)): WebAssembly.Instance;
 
@@ -85,6 +109,10 @@ export declare function isSharedArrayBuffer(value: any): value is SharedArrayBuf
 /** @public */
 export declare function isTrapError(e: Error): e is WebAssembly.RuntimeError;
 
+/** @public */
+export declare interface LoadedPayload {
+}
+
 /** @public */
 export declare interface LoadedSource extends WebAssembly.WebAssemblyInstantiatedSource {
     usedInstance: WebAssembly.Instance;
@@ -107,6 +135,7 @@ export declare interface LoadOptions {
     getTable?: (exports: WebAssembly.Exports) => WebAssembly.Table;
 }
 
+/** @public */
 export declare interface LoadPayload {
     wasmModule: WebAssembly.Module;
     wasmMemory: WebAssembly.Memory;
@@ -130,12 +159,17 @@ export declare interface MainThreadOptionsWithThreadManager extends MainThreadBa
     threadManager?: ThreadManager | (() => ThreadManager);
 }
 
+/** @public */
+export declare interface MessageEventData<T extends CommandType> {
+    __emnapi__: CommandInfo<T>;
+}
+
 /** @public */
 export declare class MessageHandler extends ThreadMessageHandler {
     napiModule: NapiModule | undefined;
     constructor(options: MessageHandlerOptions);
     instantiate(data: LoadPayload): InstantiatedSource | PromiseLike<InstantiatedSource>;
-    handle(e: any): void;
+    handle(e: WorkerMessageEvent): void;
 }
 
 /** @public */
@@ -166,8 +200,7 @@ export declare interface NapiModule {
     }
 
     init (options: InitOptions): any
-    initWorker (arg: number): void
-    executeAsyncWork (work: number): void
+    initWorker (arg: number, func: [number, number]): void
     postMessage?: (msg: any) => any
 
     waitThreadStart: boolean | number
@@ -206,16 +239,32 @@ export declare interface ReuseWorkerOptions {
     strict?: boolean;
 }
 
+/** @public */
+export declare interface SpawnThreadPayload {
+    startArg: number;
+    errorOrTid: number;
+}
+
+/** @public */
+export declare interface StartPayload {
+    tid: number;
+    arg: number;
+    sab?: Int32Array;
+}
+
 /** @public */
 export declare interface StartResult {
     exitCode: number;
     instance: WebAssembly.Instance;
 }
 
+/** @public */
+export declare interface TerminateAllThreadsPayload {
+}
+
 /** @public */
 export declare class ThreadManager {
     unusedWorkers: WorkerLike[];
-    runningWorkers: WorkerLike[];
     pthreads: Record<number, WorkerLike>;
     get nextWorkerID(): number;
     wasmModule: WebAssembly.Module | null;
@@ -226,6 +275,7 @@ export declare class ThreadManager {
     private readonly _reuseWorker;
     private readonly _beforeLoad?;
     /* Excluded from this release type: printErr */
+    threadSpawn?: ((startArg: number, errorOrTid?: number) => number);
     constructor(options: ThreadManagerOptions);
     init(): void;
     initMainThread(): void;
@@ -252,6 +302,7 @@ export declare type ThreadManagerOptions = ThreadManagerOptionsMain | ThreadMana
 /** @public */
 export declare interface ThreadManagerOptionsBase {
     printErr?: (message: string) => void;
+    threadSpawn?: (startArg: number, errorOrTid?: number) => number;
 }
 
 /** @public */
@@ -273,11 +324,12 @@ export declare class ThreadMessageHandler {
     private messagesBeforeLoad;
     protected postMessage: (message: any) => void;
     protected onLoad?: (data: LoadPayload) => WebAssembly.WebAssemblyInstantiatedSource | PromiseLike<WebAssembly.WebAssemblyInstantiatedSource>;
+    protected onError: (error: Error, type: WorkerMessageType) => void;
     constructor(options?: ThreadMessageHandlerOptions);
     /** @virtual */
     instantiate(data: LoadPayload): WebAssembly.WebAssemblyInstantiatedSource | PromiseLike<WebAssembly.WebAssemblyInstantiatedSource>;
     /** @virtual */
-    handle(e: WorkerMessageEvent): void;
+    handle(e: WorkerMessageEvent<MessageEventData<WorkerMessageType>>): void;
     private _load;
     private _start;
     protected _loaded(err: Error | null, source: WebAssembly.WebAssemblyInstantiatedSource | null, payload: LoadPayload): void;
@@ -287,6 +339,7 @@ export declare class ThreadMessageHandler {
 /** @public */
 export declare interface ThreadMessageHandlerOptions {
     onLoad?: (data: LoadPayload) => WebAssembly.WebAssemblyInstantiatedSource | PromiseLike<WebAssembly.WebAssemblyInstantiatedSource>;
+    onError?: (error: Error, type: WorkerMessageType) => void;
     postMessage?: (message: any) => void;
 }
 
@@ -360,4 +413,7 @@ export declare interface WorkerMessageEvent<T = any> {
     data: T;
 }
 
+/** @public */
+export declare type WorkerMessageType = 'load' | 'start';
+
 export { }