js-dos 7.4.9 → 8.1.0

package/src/store/auth.ts

@@ -0,0 +1,115 @@
+import { createSlice } from "@reduxjs/toolkit";
+import { getCache } from "../host/lcache";
+import { lStorage } from "../host/lstorage";
+import { DosAction, getNonSerializableStore } from "../store";
+import { dosSlice } from "./dos";
+
+const cachedAccount = "cached.account";
+
+export interface Token {
+    access_token: string,
+    refresh_token: string,
+    scope: string,
+    expires_in: number,
+    validUntilMs: number;
+};
+
+export interface Account {
+    email: string,
+    name: null | string,
+    picture: null | string,
+    token: Token,
+    premium: boolean,
+};
+
+const initAccount = (() => {
+    const params = new URLSearchParams(location.search);
+    const refreshToken = params.get("jsdos_token");
+    if (refreshToken !== null) {
+        setRefreshToken(refreshToken);
+        history.replaceState(null, "", location.href.substring(0, location.href.indexOf("?")));
+        return null;
+    } else {
+        const json = lStorage.getItem(cachedAccount);
+        const account = json !== null ? JSON.parse(json) : null;
+        return account !== null && account.token.validUntilMs - Date.now() > 1 * 60 * 60 * 1000 ?
+            account : null;
+    }
+})();
+
+const initialState: {
+    account: Account | null,
+    ready: boolean,
+} = {
+    account: initAccount,
+    ready: initAccount !== null,
+};
+
+export type AuthState = typeof initialState;
+
+export const authSlice = createSlice({
+    name: "auth",
+    initialState,
+    reducers: {
+        login: (state, action: { payload: Account }) => {
+            setRefreshToken(action.payload.token.refresh_token);
+            state.account = action.payload;
+            state.account.premium = state.account.premium ||
+                state.account.email === "dz.caiiiycuk@gmail.com" ||
+                state.account.email === "caiiiycuk@gmail.com";
+            lStorage.setItem(cachedAccount, JSON.stringify(action.payload));
+            (action as unknown as DosAction).asyncStore((store) => {
+                if (action.payload.email === "dz.caiiiycuk@gmail.com" ||
+                    action.payload.email === "caiiiycuk@gmail.com") {
+                    store.dispatch(dosSlice.actions.setSockdriveWrite(false));
+                }
+                getCache(action.payload.email)
+                    .then((cache) => getNonSerializableStore(store).cache = cache)
+                    .catch(console.error)
+                    .finally(() => {
+                        store.dispatch(authSlice.actions.ready());
+                    });
+            });
+        },
+        logout: (state, action) => {
+            clearRefreshToken();
+            lStorage.removeItem(cachedAccount);
+            (action as unknown as DosAction).asyncStore((store) => {
+                getCache("guest")
+                    .then((cache) => getNonSerializableStore(store).cache = cache)
+                    .catch(console.error);
+            });
+            state.account = null;
+        },
+        ready: (state) => {
+            state.ready = true;
+        },
+    },
+});
+
+export function postAuthMessage(action: "auth/login" | "auth/authenicate") {
+    const message = {
+        action,
+        refresh_token: action === "auth/authenicate" ? getRefreshToken() : undefined,
+        url: action === "auth/login" ? location.href : undefined,
+    };
+    document.querySelector<HTMLIFrameElement>("#authentificator")!
+        .contentWindow?.postMessage(message, "*");
+}
+
+function getRefreshToken(): string | null {
+    return lStorage.getItem("cached.rt");
+}
+
+function setRefreshToken(refreshToken: string | null) {
+    if (refreshToken === null) {
+        clearRefreshToken();
+        return;
+    }
+
+    return lStorage.setItem("cached.rt", refreshToken);
+}
+
+function clearRefreshToken() {
+    lStorage.removeItem("cached.rt");
+}

package/src/store/dos.ts

@@ -0,0 +1,305 @@
+import { createSlice } from "@reduxjs/toolkit";
+import { DosAction, getNonSerializableStore, makeStore, postJsDosEvent } from "../store";
+import { Emulators } from "emulators";
+import { lStorage } from "../host/lstorage";
+
+const alphabet = "qwertyuiopasdfghjklzxcvbnm1234567890";
+declare const emulators: Emulators;
+export interface BundleConfig {
+    name?: string,
+    version?: string,
+    backend?: string,
+    render?: string,
+};
+
+export const BackendValues = <const>["dosbox", "dosboxX"];
+export type Backend = typeof BackendValues[number];
+
+export const RenderBackendValues = <const>["webgl", "canvas"];
+export type RenderBackend = typeof RenderBackendValues[number];
+
+export const RenderAspectValues = <const>["AsIs", "1/1", "5/4", "4/3", "16/10", "16/9", "Fit"];
+export type RenderAspect = typeof RenderAspectValues[number];
+export const FitConstant = 65535;
+
+export const ImageRenderingValues = <const>["pixelated", "smooth"];
+export type ImageRendering = typeof ImageRenderingValues[number];
+
+export interface EmulatorStats {
+    cyclesPerMs: number,
+    nonSkippableSleepPreSec: number,
+    sleepPerSec: number,
+    sleepTimePerSec: number,
+    framePerSec: number,
+    soundPerSec: number,
+    msgSentPerSec: number,
+    msgRecvPerSec: number,
+    netSent: number,
+    netRecv: number,
+    driveSent: number,
+    driveRecv: number,
+    driveRecvTime: number,
+    driveCacheHit: number,
+    driveCacheMiss: number,
+    driveCacheUsed: number,
+};
+
+const initialState: {
+    step:
+    "emu-init" | "emu-error" | "emu-ready" |
+    "bnd-load" | "bnd-error" | "bnd-config" | "bnd-ready" |
+    "bnd-play",
+    emuVersion: string,
+    worker: boolean,
+    backend: Backend,
+    backendLocked: boolean,
+    backendHardware: boolean,
+    renderBackend: RenderBackend,
+    renderAspect: RenderAspect,
+    volume: number,
+    mouseSensitivity: number,
+    mouseCapture: boolean,
+    paused: boolean,
+    error: null | undefined | string,
+    bundle: string | null,
+    config: BundleConfig,
+    stats: EmulatorStats,
+    ci: boolean,
+    ciStartedAt: number,
+    network: {
+        server: "netherlands" | "newyork" | "singapore",
+        room: string,
+        ipx: "connecting" | "connected" | "disconnected" | "error",
+    },
+    imageRendering: ImageRendering,
+    sockdriveWrite: boolean,
+} = {
+    step: "emu-init",
+    emuVersion: "-",
+    error: null,
+    bundle: null,
+    config: {},
+    worker: lStorage.getItem("worker") !== "false",
+    backend: (lStorage.getItem("backend") ?? "dosbox") as Backend,
+    backendLocked: false,
+    backendHardware: (lStorage.getItem("backendHardware") !== "false"),
+    renderBackend: (lStorage.getItem("renderBackend") ?? "webgl") as RenderBackend,
+    renderAspect: (lStorage.getItem("renderAspect") ?? "AsIs") as RenderAspect,
+    volume: (Number.parseFloat(lStorage.getItem("volume") ?? "1.0")),
+    mouseSensitivity: (Number.parseFloat(lStorage.getItem("mouse_sensitivity") ?? "1.0")),
+    mouseCapture: false,
+    paused: false,
+    stats: {
+        cyclesPerMs: 0,
+        nonSkippableSleepPreSec: 0,
+        sleepPerSec: 0,
+        sleepTimePerSec: 0,
+        framePerSec: 0,
+        soundPerSec: 0,
+        msgSentPerSec: 0,
+        msgRecvPerSec: 0,
+        netRecv: 0,
+        netSent: 0,
+        driveSent: 0,
+        driveRecv: 0,
+        driveRecvTime: 0,
+        driveCacheHit: 0,
+        driveCacheMiss: 0,
+        driveCacheUsed: 0,
+    },
+    network: {
+        server: (lStorage.getItem("net.server") ?? "netherlands") as any,
+        room: randomRoom(),
+        ipx: "disconnected",
+    },
+    ci: false,
+    ciStartedAt: 0,
+    imageRendering: (lStorage.getItem("imageRendering") ?? "pixelated") as any,
+    sockdriveWrite: true,
+};
+
+export type DosState = typeof initialState;
+
+export const dosSlice = createSlice({
+    name: "dos",
+    initialState,
+    reducers: {
+        emuReady: (s, a: { payload: string }) => {
+            s.step = "emu-ready";
+            s.emuVersion = a.payload;
+        },
+        emuError: (s, a: { payload: string }) => {
+            s.step = "emu-error";
+            s.error = a.payload ?? "Unexpeceted error";
+        },
+        bndLoad: (s, a: { payload: string }) => {
+            s.step = "bnd-load";
+            s.bundle = a.payload;
+        },
+        bndError: (s, a: { payload: string }) => {
+            s.step = "bnd-error";
+            s.error = a.payload ?? "Unexpeceted error";
+        },
+        bndConfig: (s) => {
+            s.step = "bnd-config";
+        },
+        bndReady: (s, a: { payload: BundleConfig }) => {
+            s.step = "bnd-ready";
+            s.config = a.payload;
+        },
+        bndPlay: (s, a) => {
+            s.step = "bnd-play";
+            (a as unknown as DosAction).asyncStore((store) => {
+                postJsDosEvent(getNonSerializableStore(store), "bnd-play");
+            });
+        },
+        dosWorker: (s, a: { payload: boolean }) => {
+            s.worker = a.payload;
+            lStorage.setItem("worker", s.worker ? "true" : "false");
+        },
+        dosBackend: (s, a: { payload: Backend }) => {
+            s.backend = a.payload as Backend;
+        },
+        dosBackendLocked: (s, a: { payload: boolean }) => {
+            s.backendLocked = a.payload;
+        },
+        dosBackendHardware: (s, a: { payload: boolean }) => {
+            s.backendHardware = a.payload;
+            lStorage.setItem("backendHardware", s.backendHardware ? "true" : "false");
+        },
+        renderBackend: (s, a: { payload: RenderBackend }) => {
+            s.renderBackend = a.payload;
+            lStorage.setItem("renderBackend", s.renderBackend);
+        },
+        renderAspect: (s, a: { payload: RenderAspect }) => {
+            s.renderAspect = a.payload;
+            lStorage.setItem("renderAspect", s.renderAspect);
+        },
+        imageRendering: (s, a: { payload: ImageRendering }) => {
+            s.imageRendering = a.payload;
+            lStorage.setItem("imageRendering", s.imageRendering);
+        },
+        volume: (s, a: { payload: number }) => {
+            s.volume = a.payload;
+            lStorage.setItem("volume", s.volume + "");
+        },
+        mouseSensitivity: (s, a: { payload: number }) => {
+            s.mouseSensitivity = a.payload;
+            lStorage.setItem("mouse_sensitivity", s.mouseSensitivity + "");
+        },
+        mouseCapture: (s, a: { payload: boolean }) => {
+            s.mouseCapture = a.payload;
+        },
+        paused: (s, a: { payload: boolean }) => {
+            s.paused = a.payload;
+        },
+        stats: (s, a: { payload: EmulatorStats }) => {
+            s.stats = a.payload;
+        },
+        ci: (s, a: { payload: boolean }) => {
+            s.ci = a.payload;
+            if (a.payload) {
+                s.ciStartedAt = Date.now();
+            }
+        },
+        connectIpx: (s, a: { payload: { room: string, address: string } }) => {
+            if (s.network.ipx === "connected") {
+                throw new Error("Already connected");
+            }
+
+            if (!s.ci) {
+                throw new Error("DOS is not started");
+            }
+
+            const { room, address } = a.payload;
+            s.network.ipx = "connecting";
+            (a as unknown as DosAction).asyncStore((store) => {
+                const nonSerializableStore = getNonSerializableStore(store);
+                if (!nonSerializableStore.ci) {
+                    throw new Error("DOS is not started");
+                }
+
+                const canonicalAddress = address.endsWith("/") ?
+                    address.substring(0, address.length - 1) :
+                    address;
+
+                nonSerializableStore.ci.networkConnect(0 /* NetworkType.NETWORK_DOSBOX_IPX */,
+                    canonicalAddress + ":1900/ipx/" + room.replaceAll("@", "_"))
+                    .then(() => {
+                        store.dispatch(dosSlice.actions.statusIpx("connected"));
+                    })
+                    .catch((e) => {
+                        store.dispatch(dosSlice.actions.statusIpx("error"));
+                        console.error(e);
+                    });
+            });
+        },
+        statusIpx: (s, a: { payload: "error" | "connected" | "connecting" }) => {
+            s.network.ipx = a.payload;
+        },
+        disconnectIpx: (s, a) => {
+            s.network.ipx = "disconnected";
+            (a as unknown as DosAction).asyncStore((store) => {
+                getNonSerializableStore(store).ci?.networkDisconnect(0 /* IPX */);
+            });
+        },
+        setRoom: (s, a: { payload: string }) => {
+            s.network.room = a.payload;
+        },
+        setServer: (s, a: { payload: typeof initialState.network.server }) => {
+            s.network.server = a.payload;
+            lStorage.setItem("net.server", a.payload);
+        },
+        setSockdriveWrite: (s, a: { payload: boolean }) => {
+            s.sockdriveWrite = a.payload;
+        },
+    },
+});
+
+let emulatorsReady = false;
+export function initEmulators(store: ReturnType<typeof makeStore>, pathPrefix: string) {
+    store.dispatch(async (dispatch) => {
+        try {
+            if (!emulatorsReady) {
+                await initEmulatorsJs(pathPrefix);
+                emulatorsReady = true;
+            }
+            dispatch(dosSlice.actions.emuReady(emulators.version));
+        } catch (e) {
+            console.error("Unable to init emulators.js", e);
+            dispatch(dosSlice.actions.emuError((e as any).message));
+        }
+    });
+}
+
+function initEmulatorsJs(pathPrefix: string) {
+    const el = document.querySelector("#emulators.js");
+    if (el !== null) {
+        return Promise.resolve();
+    }
+
+    return new Promise<void>((resolve, reject) => {
+        const script = document.createElement("script");
+        script.async = true;
+        script.type = "text/javascript";
+        script.src = pathPrefix + "emulators.js";
+        script.onload = () => {
+            emulators.pathPrefix = pathPrefix;
+            resolve();
+        };
+        script.onerror = (err) => {
+            reject(new Error("Unable to add emulators.js. Probably you should set the " +
+                "'pathPrefix' option to point to the js-dos folder."));
+        };
+
+        document.head.appendChild(script);
+    });
+};
+
+function randomSymbol() {
+    return alphabet[Math.round(Math.random() * (alphabet.length - 1))];
+}
+
+function randomRoom() {
+    return randomSymbol() + randomSymbol() + randomSymbol();
+}

package/src/store/editor.ts

@@ -0,0 +1,61 @@
+import { createSlice } from "@reduxjs/toolkit";
+import { DosConfig } from "emulators";
+import { Node } from "react-checkbox-tree";
+import { dosboxconf } from "../frame/editor/defaults";
+
+const initialState: {
+    // step: "empty" | "extract" | "ready" | "error",
+    configChanged: boolean,
+    bundleConfig: DosConfig | null,
+    errorMessage: string | null,
+    fs: Node[],
+} = {
+    // step: "empty",
+    configChanged: false,
+    bundleConfig: null,
+    errorMessage: null,
+    fs: [],
+};
+
+export type EditorState = typeof initialState;
+
+export const editorSlice = createSlice({
+    name: "editor",
+    initialState,
+    reducers: {
+        init: (s, a: { payload: DosConfig | null }) => {
+            if (a.payload === null) {
+                s.configChanged = true;
+                s.bundleConfig = {
+                    dosboxConf: dosboxconf[0].contents,
+                    jsdosConf: {
+                        version: "js-dos-v8",
+                    },
+                };
+            } else {
+                s.configChanged = false;
+                s.bundleConfig = a.payload;
+            }
+        },
+        dosboxConf: (s, a: { payload: string }) => {
+            s.configChanged = true;
+            s.bundleConfig!.dosboxConf = a.payload;
+        },
+        // empty: (s) => {
+        //     s.step = "empty";
+        // },
+        // extract: (s) => {
+        //     s.step = "extract";
+        // },
+        // ready: (s) => {
+        //     s.step = "ready";
+        // },
+        // config: (s, a: { payload: DosConfig | null }) => {
+        //     s.bundleConfig = a.payload;
+        // },
+        // error: (s, a: { payload: string }) => {
+        //     s.step = "error";
+        //     s.errorMessage = a.payload;
+        // },
+    },
+});

package/src/store/init.ts

@@ -0,0 +1,48 @@
+import { createSlice } from "@reduxjs/toolkit";
+import { lStorage } from "../host/lstorage";
+
+export const sockdriveBackendNames = ["localhost", "js-dos"];
+export type SockdriveBackendName = typeof sockdriveBackendNames[number];
+export const sockdriveBackend: {
+    [key: SockdriveBackendName]: {
+        sockdriveEndpoint: string,
+        sockdriveWssEndpoint: string,
+    }
+} = {
+    "js-dos": {
+        sockdriveEndpoint: "https://backend.make-vm.com:8001",
+        sockdriveWssEndpoint: "wss://backend.make-vm.com:8001",
+    },
+    "localhost": {
+        sockdriveEndpoint: "http://localhost:8001",
+        sockdriveWssEndpoint: "ws://localhost:8001",
+    },
+};
+
+export interface InitState {
+    uid: string,
+    sockdriveBackendName: SockdriveBackendName,
+};
+
+let storeUid = -1;
+export function createInitSlice() {
+    storeUid += 1;
+    return {
+        storeUid,
+        slice: createSlice({
+            name: "init",
+            initialState: {
+                uid: storeUid,
+                sockdriveBackendName: lStorage.getItem("sockdrive.backend.name") ?? "js-dos",
+            },
+            reducers: {
+                setSockdriveBackendName: (state, a: { payload: SockdriveBackendName }) => {
+                    state.sockdriveBackendName = a.payload;
+                    lStorage.setItem("sockdrive.backend.name", a.payload);
+                },
+            },
+        }),
+    };
+}
+
+export const initSlice = createInitSlice().slice;

package/src/store/storage.ts

@@ -0,0 +1,32 @@
+import { createSlice } from "@reduxjs/toolkit";
+
+const initialState: {
+    recived: number,
+    total: number,
+    ready: boolean,
+} = {
+    recived: 0,
+    total: 0,
+    ready: false,
+};
+
+export type StorageState = typeof initialState;
+
+export const storageSlice = createSlice({
+    name: "storage",
+    initialState,
+    reducers: {
+        reset: (s) => {
+            s.recived = -1;
+            s.total = 0;
+            s.ready = false;
+        },
+        progress: (s, a: { payload: [number, number ] }) => {
+            s.recived = a.payload[0];
+            s.total = a.payload[1];
+        },
+        ready: (s) => {
+            s.ready = true;
+        },
+    },
+});