wasm-idle 0.7.2 → 1.0.0

package/dist/playground/loadingProgress.d.ts

@@ -0,0 +1,16 @@
+import type { ProgressLike } from '@wasm-idle/core';
+export interface LoadingProgressState {
+    visible: boolean;
+    value: number;
+    stage: string;
+    indeterminate: boolean;
+}
+interface LoadingProgressControllerOptions {
+    onChange: (state: LoadingProgressState) => void;
+}
+export interface LoadingProgressController extends ProgressLike {
+    start: (stage?: string) => ProgressLike;
+    reset: () => void;
+}
+export declare function createLoadingProgressController({ onChange }: LoadingProgressControllerOptions): LoadingProgressController;
+export {};

package/dist/playground/loadingProgress.js

@@ -0,0 +1,166 @@
+const hiddenState = () => ({
+    visible: false,
+    value: 0,
+    stage: '',
+    indeterminate: false
+});
+// These are presentation estimates for runtimes that cannot measure a phase.
+// They must never substitute for an explicit ready or settled event.
+const estimatedPhaseProgress = {
+    legacy: 0.05,
+    resolving: 0.05,
+    downloading: 0.1,
+    verifying: 0.45,
+    decompressing: 0.55,
+    initializing: 0.65,
+    compiling: 0.75,
+    linking: 0.9,
+    instantiating: 0.95,
+    starting: 0.02
+};
+export function createLoadingProgressController({ onChange }) {
+    let generation = 0;
+    let active = false;
+    let state = hiddenState();
+    let activityPhase = null;
+    let measurementTotal = null;
+    let measurementValue = 0;
+    let measurementPoisoned = false;
+    let currentOperationId = null;
+    const retiredOperationIds = new Set();
+    const emit = () => onChange({ ...state });
+    const resetActivityPhase = () => {
+        activityPhase = null;
+        measurementTotal = null;
+        measurementValue = 0;
+        measurementPoisoned = false;
+    };
+    const resetOperationTracking = () => {
+        currentOperationId = null;
+        retiredOperationIds.clear();
+    };
+    const emitHidden = () => {
+        active = false;
+        resetActivityPhase();
+        resetOperationTracking();
+        state = hiddenState();
+        emit();
+    };
+    const begin = (stage) => {
+        active = true;
+        resetActivityPhase();
+        resetOperationTracking();
+        state = { visible: true, value: 0, stage, indeterminate: false };
+        emit();
+    };
+    const reportEvent = (expectedGeneration, event) => {
+        if (!active || expectedGeneration !== generation)
+            return;
+        const operationId = typeof event.operationId === 'string' && event.operationId.trim()
+            ? event.operationId
+            : null;
+        if (operationId !== null) {
+            if (retiredOperationIds.has(operationId))
+                return;
+            if (currentOperationId !== operationId) {
+                if (currentOperationId !== null)
+                    retiredOperationIds.add(currentOperationId);
+                currentOperationId = operationId;
+                resetActivityPhase();
+            }
+        }
+        else if (currentOperationId !== null && event.kind !== 'settled') {
+            // Unscoped page-level activity may precede the first runtime operation, while an
+            // unscoped settlement closes the owning page session. Neither unscoped activity
+            // nor readiness may supersede a correlated operation once it has started.
+            return;
+        }
+        if (event.kind === 'ready' || event.kind === 'settled') {
+            emitHidden();
+            return;
+        }
+        const nextActivityPhase = `${event.operationId ?? ''}\u0000${event.phase}\u0000${event.phaseId ?? ''}`;
+        if (activityPhase !== nextActivityPhase) {
+            activityPhase = nextActivityPhase;
+            measurementTotal = null;
+            measurementValue = 0;
+            measurementPoisoned = false;
+        }
+        const estimate = typeof event.estimatedFraction === 'number' && Number.isFinite(event.estimatedFraction)
+            ? event.estimatedFraction
+            : estimatedPhaseProgress[event.phase];
+        const estimatedValue = Math.min(0.99, Math.max(state.value, estimate, 0));
+        const { measurement } = event;
+        if (!measurement) {
+            state = {
+                visible: true,
+                value: estimatedValue,
+                stage: event.label,
+                indeterminate: false
+            };
+            emit();
+            return;
+        }
+        const validMeasurement = measurement.kind === 'bytes' &&
+            Number.isSafeInteger(measurement.completed) &&
+            measurement.completed >= 0 &&
+            Number.isSafeInteger(measurement.total) &&
+            measurement.total > 0 &&
+            measurement.completed <= measurement.total;
+        if (!validMeasurement ||
+            (measurementTotal !== null && measurementTotal !== measurement.total)) {
+            measurementPoisoned = true;
+        }
+        if (measurementPoisoned) {
+            state = {
+                visible: true,
+                value: estimatedValue,
+                stage: event.label,
+                indeterminate: false
+            };
+            emit();
+            return;
+        }
+        measurementTotal ??= measurement.total;
+        measurementValue = Math.max(measurementValue, measurement.completed / measurement.total);
+        state = {
+            visible: true,
+            value: measurementValue,
+            stage: event.label,
+            indeterminate: false
+        };
+        emit();
+    };
+    const setLegacyActivity = (expectedGeneration, value, stage) => {
+        reportEvent(expectedGeneration, {
+            kind: 'activity',
+            phase: 'legacy',
+            label: stage || state.stage,
+            estimatedFraction: value
+        });
+    };
+    const start = (stage = 'Loading runtime') => {
+        generation += 1;
+        const sessionGeneration = generation;
+        begin(stage);
+        return Object.freeze({
+            set: (value, nextStage) => setLegacyActivity(sessionGeneration, value, nextStage),
+            report: (event) => reportEvent(sessionGeneration, event)
+        });
+    };
+    const set = (value, stage) => {
+        if (!active)
+            return;
+        setLegacyActivity(generation, value, stage);
+    };
+    const report = (event) => {
+        if (!active)
+            return;
+        reportEvent(generation, event);
+    };
+    const reset = () => {
+        generation += 1;
+        emitHidden();
+    };
+    return { start, set, report, reset };
+}

package/dist/playground/lua.d.ts

@@ -0,0 +1,44 @@
+import { type PlaygroundRuntimeAssets } from './assets';
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import type { Sandbox, SandboxProgress } from './sandbox';
+declare class Lua implements Sandbox {
+    output: any;
+    worker?: Worker;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    moduleUrl: string;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    private activeOperation;
+    private disposed;
+    private disposePromise;
+    private readonly disposeCancellation;
+    private readonly workerSession;
+    private requireOperationIdle;
+    private beginOperation;
+    private isOperationActive;
+    private releaseOperation;
+    private cleanupOperation;
+    private releaseBeforeSession;
+    private bindPreSessionAbort;
+    private bindAbortSignal;
+    private bindOperationTimeout;
+    private resetExplicitStdinState;
+    private finishExplicitStdin;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress): Promise<void>;
+    write(input: string): void;
+    eof(): void;
+    private flushPendingInput;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    private cancelOperation;
+    kill(): void;
+    terminate(reason?: unknown): void;
+    clear(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export default Lua;