js-dos 8.1.4 → 8.1.6

package/dist/emulators/types/impl/emulators-impl.d.ts

@@ -0,0 +1,26 @@
+import { Emulators, CommandInterface, BackendOptions, DosConfig, InitFs, InitBundleEntry } from "../emulators";
+import { IWasmModules } from "./modules";
+import DosBundle from "../dos/bundle/dos-bundle";
+import { TransportLayer } from "../protocol/protocol";
+declare class EmulatorsImpl implements Emulators {
+    pathPrefix: string;
+    version: string;
+    wdosboxJs: string;
+    wdosboxxJs: string;
+    private wasmModulesPromise?;
+    bundle(): Promise<DosBundle>;
+    bundleConfig(bundle: InitBundleEntry): Promise<DosConfig | null>;
+    bundleUpdateConfig(bundle: InitBundleEntry, config: DosConfig): Promise<Uint8Array>;
+    dosboxNode(init: InitFs, options?: BackendOptions): Promise<CommandInterface>;
+    dosboxDirect(init: InitFs, options?: BackendOptions): Promise<CommandInterface>;
+    dosboxWorker(init: InitFs, options?: BackendOptions): Promise<CommandInterface>;
+    dosboxXNode(init: InitFs, options?: BackendOptions): Promise<CommandInterface>;
+    dosboxXDirect(init: InitFs, options?: BackendOptions): Promise<CommandInterface>;
+    dosboxXWorker(init: InitFs, options?: BackendOptions): Promise<CommandInterface>;
+    backend(init: InitFs, transportLayer: TransportLayer, options?: BackendOptions): Promise<CommandInterface>;
+    wasmModules(): Promise<IWasmModules>;
+    dosDirect(init: InitFs): Promise<CommandInterface>;
+    dosWorker(init: InitFs): Promise<CommandInterface>;
+}
+declare const emulators: EmulatorsImpl;
+export default emulators;

package/dist/emulators/types/impl/modules.d.ts

@@ -0,0 +1,38 @@
+export interface WasmModule {
+    instantiate: (module?: any) => Promise<any>;
+}
+export interface IWasmModules {
+    libzip: () => Promise<WasmModule>;
+    dosbox: () => Promise<WasmModule>;
+    dosboxx: () => Promise<WasmModule>;
+}
+interface Globals {
+    exports: {
+        [moduleName: string]: any;
+    };
+    compiled: {
+        [moduleName: string]: Promise<WasmModule>;
+    };
+}
+declare class Host {
+    wasmSupported: boolean;
+    globals: Globals;
+    constructor();
+}
+export declare const host: Host;
+export declare class WasmModulesImpl implements IWasmModules {
+    private pathPrefix;
+    private wdosboxJs;
+    private wdosboxxJs;
+    private libzipPromise?;
+    private dosboxPromise?;
+    private dosboxxPromise?;
+    wasmSupported: boolean;
+    constructor(pathPrefix: string, wdosboxJs: string, wdosboxxJs: string);
+    libzip(): Promise<WasmModule>;
+    dosbox(): Promise<WasmModule>;
+    dosboxx(): Promise<WasmModule>;
+    private loadModule;
+}
+export declare function loadWasmModule(url: string, moduleName: string, onprogress: (stage: string, total: number, loaded: number) => void): Promise<WasmModule>;
+export {};

package/dist/emulators/types/libzip/libzip.d.ts

@@ -0,0 +1,16 @@
+export default class LibZip {
+    module: any;
+    private home;
+    constructor(module: any, home?: string);
+    zipFromFs(changedAfterMs?: number): Promise<Uint8Array>;
+    zipToFs(zipArchive: Uint8Array, path?: string, filter?: string): Promise<void>;
+    writeFile(file: string, body: ArrayBuffer | Uint8Array | string): void;
+    readFile(file: string, encoding?: "binary" | "utf8"): Promise<string | Uint8Array>;
+    exists(file: string): boolean;
+    destroy(): any;
+    private normalizeFilename;
+    private createPath;
+    private chdirToHome;
+    private chdir;
+    zipAddFile(archive: string, file: string): Promise<void>;
+}

package/dist/emulators/types/protocol/messages-queue.d.ts

@@ -0,0 +1,8 @@
+import { ServerMessage, MessageHandler } from "./protocol";
+export declare class MessagesQueue {
+    private messages;
+    handler(name: ServerMessage, props: {
+        [key: string]: any;
+    }): void;
+    sendTo(handler: MessageHandler): void;
+}

package/dist/emulators/types/protocol/protocol.d.ts

@@ -0,0 +1,128 @@
+import { CommandInterface, NetworkType, BackendOptions, DosConfig, InitFsEntry } from "../emulators";
+import { CommandInterfaceEventsImpl } from "../impl/ci-impl";
+export type ClientMessage = "wc-install" | "wc-run" | "wc-pack-fs-to-bundle" | "wc-add-key" | "wc-mouse-move" | "wc-mouse-button" | "wc-mouse-sync" | "wc-exit" | "wc-sync-sleep" | "wc-pause" | "wc-resume" | "wc-mute" | "wc-unmute" | "wc-connect" | "wc-disconnect" | "wc-backend-event" | "wc-asyncify-stats" | "wc-fs-tree" | "wc-fs-get-file" | "wc-send-data-chunk";
+export type ServerMessage = "ws-extract-progress" | "ws-ready" | "ws-server-ready" | "ws-frame-set-size" | "ws-update-lines" | "ws-log" | "ws-warn" | "ws-err" | "ws-stdout" | "ws-exit" | "ws-persist" | "ws-sound-init" | "ws-sound-push" | "ws-config" | "ws-sync-sleep" | "ws-connected" | "ws-disconnected" | "ws-asyncify-stats" | "ws-fs-tree" | "ws-send-data-chunk";
+export type MessageHandler = (name: ServerMessage, props: {
+    [key: string]: any;
+}) => void;
+export interface TransportLayer {
+    sessionId: string;
+    sendMessageToServer(name: ClientMessage, props: {
+        [key: string]: any;
+    }, transfer?: ArrayBuffer[]): void;
+    initMessageHandler(handler: MessageHandler): void;
+    exit?: () => void;
+}
+export interface FrameLine {
+    start: number;
+    heapu8: Uint8Array;
+}
+export interface DataChunk {
+    type: "ok" | "file" | "bundle";
+    name: string;
+    data: ArrayBuffer | null;
+}
+export interface AsyncifyStats {
+    messageSent: number;
+    messageReceived: number;
+    messageFrame: number;
+    messageSound: number;
+    nonSkippableSleepCount: number;
+    sleepCount: number;
+    sleepTime: number;
+    cycles: number;
+    netSent: number;
+    netRecv: number;
+    driveSent: number;
+    driveRecv: number;
+    driveRecvTime: number;
+    driveCacheHit: number;
+    driveCacheMiss: number;
+    driveCacheUsed: number;
+}
+export interface FsNode {
+    name: string;
+    size: number | null;
+    nodes: FsNode[] | null;
+}
+export declare class CommandInterfaceOverTransportLayer implements CommandInterface {
+    private startedAt;
+    private frameWidth;
+    private frameHeight;
+    private rgb;
+    private rgba;
+    private freq;
+    private utf8Decoder;
+    private init?;
+    private transport;
+    private ready;
+    private persistPromise?;
+    private persistResolve?;
+    private exitPromise?;
+    private exitResolve?;
+    private eventsImpl;
+    private keyMatrix;
+    private configPromise;
+    private configResolve;
+    private panicMessages;
+    private connectPromise;
+    private connectResolve;
+    private connectReject;
+    private disconnectPromise;
+    private disconnectResolve;
+    private asyncifyStatsPromise;
+    private asyncifyStatsResolve;
+    private fsTreePromise;
+    private fsTreeResolve;
+    private fsGetFilePromise;
+    private fsGetFileResolve;
+    private fsGetFileParts;
+    private dataChunkPromise;
+    private dataChunkResolve;
+    options: BackendOptions;
+    constructor(init: InitFsEntry[], transport: TransportLayer, ready: (err: Error | null) => void, options: BackendOptions);
+    private sendClientMessage;
+    private onServerMessage;
+    private onConfig;
+    private onFrameSize;
+    private onFrameLines;
+    private onSoundInit;
+    private onSoundPush;
+    private onLog;
+    private onWarn;
+    private onErr;
+    private onStdout;
+    config(): Promise<DosConfig>;
+    width(): number;
+    height(): number;
+    soundFrequency(): number;
+    screenshot(): Promise<ImageData>;
+    simulateKeyPress(...keyCodes: number[]): void;
+    sendKeyEvent(keyCode: number, pressed: boolean): void;
+    addKey(keyCode: number, pressed: boolean, timeMs: number): void;
+    sendMouseMotion(x: number, y: number): void;
+    sendMouseRelativeMotion(x: number, y: number): void;
+    sendMouseButton(button: number, pressed: boolean): void;
+    sendMouseSync(): void;
+    sendBackendEvent(payload: any): void;
+    persist(onlyChanges?: boolean): Promise<Uint8Array | null>;
+    private onPersist;
+    pause(): void;
+    resume(): void;
+    mute(): void;
+    unmute(): void;
+    exit(): Promise<void>;
+    private onExit;
+    events(): CommandInterfaceEventsImpl;
+    networkConnect(networkType: NetworkType, address: string): Promise<void>;
+    networkDisconnect(networkType: NetworkType): Promise<void>;
+    asyncifyStats(): Promise<AsyncifyStats>;
+    fsTree(): Promise<FsNode>;
+    fsReadFile(file: string): Promise<Uint8Array>;
+    fsWriteFile(file: string, contents: ReadableStream<Uint8Array> | Uint8Array): Promise<void>;
+    fsDeleteFile(file: string): Promise<void>;
+    private sendDataChunk;
+    private sendFullDataChunk;
+    private dataChunkKey;
+    private mergeChunks;
+}