js-dos 8.1.4 → 8.1.6

package/src/frame/stats-frame.tsx

@@ -1,87 +0,0 @@
-import { useSelector } from "react-redux";
-import { State } from "../store";
-
-export function StatsFrame() {
-    const startedAt = useSelector((state: State) => state.dos.ciStartedAt);
-    const stats = useSelector((state: State) => state.dos.stats);
-    const cycles = Math.round(useSelector((state: State) => state.dos.stats.cyclesPerMs) / 1000);
-    const driveRecvMb = Math.round(stats.driveRecv / 1024 / 1024 * 100) / 100;
-    const driveSpeedMb = (stats.driveRecvTime / 1000) > 1 ?
-        Math.round(driveRecvMb / stats.driveRecvTime * 1000 * 100) / 100 : 0;
-    return <div class="stats-frame frame-root items-start px-4">
-        <div class="w-full overflow-x-auto">
-            <table class="table table-compact w-full">
-                <thead>
-                    <tr>
-                        <th>Metric</th>
-                        <th>Value</th>
-                    </tr>
-                </thead>
-                <tbody>
-                    <tr>
-                        <td>Uptime</td>
-                        <td>{Math.round((Date.now() - startedAt) / 100) / 10} s</td>
-                    </tr>
-                    <tr>
-                        <td>Cycles/ms</td>
-                        { cycles <= 0 && <td>~ K</td> }
-                        { cycles > 0 && cycles <= 1000 && <td>{cycles} K</td> }
-                        { cycles > 1000 && <td>{Math.round(cycles / 1000)} KK</td> }
-                    </tr>
-                    <tr>
-                        <td>NonSkipSleep COUNT/s</td>
-                        <td>{stats.nonSkippableSleepPreSec}</td>
-                    </tr>
-                    <tr>
-                        <td>Sleep COUNT/s</td>
-                        <td>{stats.sleepPerSec}</td>
-                    </tr>
-                    <tr>
-                        <td>Sleep TIME/s</td>
-                        <td>{stats.sleepTimePerSec}</td>
-                    </tr>
-                    <tr>
-                        <td>Msg FRAME/s</td>
-                        <td>{stats.framePerSec}</td>
-                    </tr>
-                    <tr>
-                        <td>Msg SOUND/s</td>
-                        <td>{stats.soundPerSec}</td>
-                    </tr>
-                    <tr>
-                        <td>Msg SENT/s</td>
-                        <td>{stats.msgSentPerSec}</td>
-                    </tr>
-                    <tr>
-                        <td>Msg RECV/s</td>
-                        <td>{stats.msgRecvPerSec}</td>
-                    </tr>
-                    <tr>
-                        <td>Net SENT/s</td>
-                        <td>{Math.round(stats.netSent / 1024 * 100) / 100}Kb</td>
-                    </tr>
-                    <tr>
-                        <td>Net RECV/s</td>
-                        <td>{Math.round(stats.netRecv / 1024 * 100) / 100}Kb</td>
-                    </tr>
-                    <tr>
-                        <td>HDD RECV/s</td>
-                        <td>{driveRecvMb}Mb (~{driveSpeedMb}Mb/s)</td>
-                    </tr>
-                    <tr>
-                        <td>HDD SENT/s</td>
-                        <td>{Math.round(stats.driveSent / 1024 / 1024 * 100) / 100}Mb</td>
-                    </tr>
-                    <tr>
-                        <td>HDD Cache</td>
-                        <td>{Math.round(stats.driveCacheUsed / 1024 / 1024 * 100) / 100}Mb</td>
-                    </tr>
-                    <tr>
-                        <td>HDD Cache Hit/Miss</td>
-                        <td>{stats.driveCacheHit} / {stats.driveCacheMiss}</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-    </div>;
-}

package/src/host/bundle-storage.ts

@@ -1,91 +0,0 @@
-import { storageSlice } from "../store/storage";
-import { Account } from "../store/auth";
-import { brCdn } from "../v8/config";
-import { Store, getNonSerializableStore } from "../store";
-
-export function bundleFromFile(file: File, store: Store): Promise<Uint8Array> {
-    return new Promise<Uint8Array>((resolve) => {
-        store.dispatch(storageSlice.actions.reset());
-        const reader = new FileReader();
-        reader.addEventListener("load", async (e) => {
-            resolve(new Uint8Array(reader.result as ArrayBuffer));
-        });
-        reader.addEventListener("progress", (e) => {
-            store.dispatch(storageSlice.actions.progress([e.loaded, e.total]));
-        });
-        reader.readAsArrayBuffer(file);
-    });
-}
-
-
-export async function bundleFromChanges(url: string, account: Account | null,
-                                        store: Store): Promise<Uint8Array | null> {
-    if (account === null || !account.premium) {
-        return await getNonSerializableStore(store).cache.get(url).catch(() => null);
-    }
-
-    try {
-        const response = await fetch(url, {
-            cache: "no-cache",
-        });
-
-        if (response.status !== 200) {
-            throw new Error("Resource not avalible (" + response.status + "): " + response.statusText);
-        }
-
-        return response.arrayBuffer().then((b) => new Uint8Array(b));
-    } catch (e: any) {
-        return await getNonSerializableStore(store).cache.get(url).catch(() => null);
-    }
-}
-
-export async function bundleFromUrl(url: string, store: Store): Promise<Uint8Array> {
-    try {
-        return await getNonSerializableStore(store).cache.get(url);
-    } catch (e: any) {
-        // ignore
-    }
-
-    store.dispatch(storageSlice.actions.reset());
-    const response = await fetch(url, {
-        cache: "no-store",
-    });
-
-    if (response.status !== 200) {
-        throw new Error("Resource not avalible (" + response.status + "): " + response.statusText);
-    }
-
-    const lenHeader = response.headers.get("Content-Length");
-    const length = lenHeader === null ? 0 :
-        Number.parseInt(lenHeader);
-    const reader = response.body!.getReader();
-
-    let received = 0;
-    const chunks: Uint8Array[] = [];
-    while (true) {
-        const { done, value } = await reader.read();
-
-        if (done) {
-            break;
-        }
-
-        chunks.push(value);
-        received += value.length;
-
-        const bytes = Math.min(url.startsWith(brCdn) ? received / 2 : received, length);
-        store.dispatch(storageSlice.actions.progress([bytes, length]));
-    }
-
-    let offset = 0;
-    const complete = new Uint8Array(received);
-    for (const next of chunks) {
-        complete.set(next, offset);
-        offset += next.length;
-    }
-
-    getNonSerializableStore(store).cache
-        .put(url, complete)
-        .catch(console.error);
-
-    return complete;
-};

package/src/host/fullscreen.ts

@@ -1,35 +0,0 @@
-import { Store, getNonSerializableStore } from "../store";
-import { uiSlice } from "../store/ui";
-
-export function browserSetFullScreen(fullScreen: boolean, store: Store) {
-    const root = getNonSerializableStore(store).root as any;
-    if (fullScreen) {
-        if (root.requestFullscreen) {
-            root.requestFullscreen();
-        } else if (root.webkitRequestFullscreen) {
-            root.webkitRequestFullscreen();
-        } else if (root.mozRequestFullScreen) {
-            root.mozRequestFullScreen();
-        } else if (root.msRequestFullscreen) {
-            root.msRequestFullscreen();
-        } else if (root.webkitEnterFullscreen) {
-            root.webkitEnterFullscreen();
-        } else {
-            root.classList.add("jsdos-fullscreen-workaround");
-        }
-    } else {
-        if (root.classList.contains("jsdos-fullscreen-workaround")) {
-            root.classList.remove("jsdos-fullscreen-workaround");
-        } else if (document.exitFullscreen) {
-            document.exitFullscreen();
-        } else if ((document as any).webkitExitFullscreen) {
-            (document as any).webkitExitFullscreen();
-        } else if ((document as any).mozCancelFullScreen) {
-            (document as any).mozCancelFullScreen();
-        } else if ((document as any).msExitFullscreen) {
-            (document as any).msExitFullscreen();
-        }
-    }
-
-    store.dispatch(uiSlice.actions.setFullScreen(fullScreen));
-}

package/src/host/lcache.ts

@@ -1,203 +0,0 @@
-/* eslint @typescript-eslint/no-unused-vars: 0 */
-
-export interface Cache {
-    readonly owner: string;
-    put: (key: string, data: Uint8Array) => Promise<void>;
-    get: (key: string, defaultValue?: Uint8Array) => Promise<Uint8Array>;
-    del: (key: string) => Promise<void>;
-    keys: () => Promise<string[]>;
-    forEach: (each: (key: string, value: Uint8Array) => void) => Promise<void>;
-    close: () => void;
-}
-
-export class CacheNoop implements Cache {
-    public owner = "";
-
-    public close() {
-    }
-
-    public put(key: string, data: Uint8Array): Promise<void> {
-        return Promise.resolve();
-    }
-
-    public get(key: string, defaultValue?: Uint8Array): Promise<Uint8Array> {
-        if (defaultValue !== undefined) {
-            return Promise.resolve(defaultValue);
-        }
-        return Promise.reject(new Error("Cache is not supported on this host"));
-    }
-
-    public del(key: string): Promise<void> {
-        return Promise.resolve();
-    }
-
-    public keys(): Promise<string[]> {
-        return Promise.resolve([]);
-    }
-
-    public forEach(each: (key: string, value: Uint8Array) => void) {
-        return Promise.resolve();
-    }
-}
-
-class LCache implements Cache {
-    public owner: string;
-    private storeName = "files";
-    private indexedDB: IDBFactory;
-    private db: IDBDatabase | null = null;
-
-    constructor(owner: string,
-        onready: (cache: Cache) => void,
-        onerror: (msg: string) => void) {
-        this.owner = owner;
-        this.indexedDB = (typeof window === "undefined" ? undefined : window.indexedDB ||
-            (window as any).mozIndexedDB ||
-            (window as any).webkitIndexedDB || (window as any).msIndexedDB) as any;
-
-        if (!this.indexedDB) {
-            onerror("Indexed db is not supported on this host");
-            return;
-        }
-
-        try {
-            const openRequest = this.indexedDB.open("js-dos-cache (" + owner + ")", 1);
-            openRequest.onerror = (event) => {
-                onerror("Can't open cache database: " + openRequest.error?.message);
-            };
-            openRequest.onsuccess = (event) => {
-                this.db = openRequest.result;
-                onready(this);
-            };
-            openRequest.onupgradeneeded = (event) => {
-                try {
-                    this.db = openRequest.result;
-                    this.db.onerror = (event) => {
-                        onerror("Can't upgrade cache database");
-                    };
-
-                    const objectStore = this.db.createObjectStore(this.storeName);
-                    objectStore.createIndex("key", "", {
-                        unique: true,
-                        multiEntry: false,
-                    });
-                } catch (e) {
-                    onerror("Can't upgrade cache database");
-                }
-            };
-        } catch (e: any) {
-            onerror("Can't open cache database: " + e.message);
-        }
-    }
-
-    public close() {
-        if (this.db !== null) {
-            this.db.close();
-            this.db = null;
-        }
-    }
-
-    public put(key: string, data: Uint8Array): Promise<void> {
-        return new Promise<void>((resolve, reject) => {
-            if (this.db === null) {
-                resolve();
-                return;
-            }
-
-            const transaction = this.db.transaction(this.storeName, "readwrite");
-            const request = transaction.objectStore(this.storeName).put(data.buffer, key);
-            request.onerror = () => reject;
-            request.onsuccess = () => resolve();
-        });
-    }
-
-    public del(key: string): Promise<void> {
-        return new Promise<void>((resolve, reject) => {
-            if (this.db === null) {
-                resolve();
-                return;
-            }
-
-            const transaction = this.db.transaction(this.storeName, "readwrite");
-            const request = transaction.objectStore(this.storeName).delete(key);
-            request.onerror = () => reject;
-            request.onsuccess = () => resolve();
-        });
-    }
-
-    public get(key: string, defaultValue?: Uint8Array): Promise<Uint8Array> {
-        return new Promise<Uint8Array>((resolve, reject) => {
-            function rejectOrResolve(message: string) {
-                if (defaultValue === undefined) {
-                    reject(new Error(message));
-                } else {
-                    resolve(defaultValue);
-                }
-            }
-
-
-            if (this.db === null) {
-                rejectOrResolve("db is not initalized");
-                return;
-            }
-
-            const transaction = this.db.transaction(this.storeName, "readonly");
-            const request = transaction.objectStore(this.storeName).get(key) as IDBRequest<ArrayBuffer>;
-            request.onerror = () => reject(new Error("Can't read value for key '" + key + "'"));
-            request.onsuccess = () => {
-                if (request.result) {
-                    resolve(new Uint8Array(request.result));
-                } else {
-                    rejectOrResolve("Result is empty for key '" + key + "', result: " + request.result);
-                }
-            };
-        });
-    }
-
-    public keys(): Promise<string[]> {
-        return new Promise<string[]>((resolve, reject) => {
-            if (this.db === null) {
-                resolve([]);
-                return;
-            }
-
-            const transaction = this.db.transaction(this.storeName, "readonly");
-            const request = transaction.objectStore(this.storeName).index("key").getAllKeys();
-            request.onerror = () => reject;
-            request.onsuccess = (event) => {
-                const keys = (event.target as any).result as string[];
-                resolve(keys);
-            };
-        });
-    }
-
-    public forEach(each: (key: string, value: Uint8Array) => void): Promise<void> {
-        return new Promise<void>((resolve, reject) => {
-            if (this.db === null) {
-                resolve();
-                return;
-            }
-
-            const transaction = this.db.transaction(this.storeName, "readonly");
-            const request = transaction.objectStore(this.storeName).openCursor();
-            request.onerror = () => reject;
-            request.onsuccess = (event) => {
-                const cursor = (event.target as any).result as IDBCursorWithValue;
-                if (cursor) {
-                    each(cursor.key.toString(), new Uint8Array(cursor.value));
-                    cursor.continue();
-                } else {
-                    resolve();
-                }
-            };
-        });
-    }
-}
-
-export function getCache(owner: string): Promise<Cache> {
-    return new Promise((resolve) => {
-        new LCache(owner, resolve, (msg: string) => {
-            console.error("Can't open IndexedDB cache", msg);
-            resolve(new CacheNoop());
-        });
-    });
-}

package/src/host/lstorage.ts

@@ -1,156 +0,0 @@
-const MAX_VALUE_SIZE = 1024;
-const NEXT_PART_SYMBOL = "@";
-const NEXT_PART_SYFFIX = ".";
-
-class MemStorage implements Storage {
-    length = 0;
-
-    private storage: {[key: string]: string} = {};
-
-    setItem(key: string, value: string): void {
-        this.storage[key] = value;
-        this.length = Object.keys(this.storage).length;
-    }
-
-    getItem(key: string): string | null {
-        const value = this.storage[key];
-        return value === undefined ? null : value;
-    }
-
-    removeItem(key: string): void {
-        delete this.storage[key];
-        this.length = Object.keys(this.storage).length;
-    }
-
-    key(index: number): string | null {
-        const keys = Object.keys(this.storage);
-        return keys[index] === undefined ? null : keys[index];
-    }
-
-    clear() {
-        this.length = 0;
-        this.storage = {};
-    }
-}
-
-
-class LStorage implements Storage {
-    private backend: Storage;
-    length: number;
-    prefix: string;
-
-    constructor(backend: Storage | undefined, prefix: string) {
-        this.prefix = prefix;
-
-        try {
-            this.backend = backend || localStorage;
-            this.testBackend();
-        } catch (e) {
-            this.backend = new MemStorage();
-        }
-
-        this.length = this.backend.length;
-
-        if (typeof this.backend.sync === "function") {
-            (this as any).sync = (callback: any) => {
-                this.backend.sync(callback);
-            };
-        }
-    }
-
-    private testBackend() {
-        const testKey = this.prefix + ".test.record";
-        const testValue = "123";
-        this.backend.setItem(testKey, testValue);
-        const readedValue = this.backend.getItem(testKey);
-        this.backend.removeItem(testKey);
-        const valid = readedValue === testValue && this.backend.getItem(testKey) === null;
-
-        if (!valid) {
-            throw new Error("Storage backend is not working properly");
-        }
-    }
-
-    setLocalStoragePrefix(prefix: string) {
-        this.prefix = prefix;
-    }
-
-    clear(): void {
-        if (!this.backend.length) {
-            return;
-        }
-
-        const toRemove: string[] = [];
-        for (let i = 0; i < this.backend.length; ++i) {
-            const next = this.backend.key(i);
-            if (next && next.startsWith(this.prefix)) {
-                toRemove.push(next);
-            }
-        }
-
-        for (const next of toRemove) {
-            this.backend.removeItem(next);
-        }
-        this.length = this.backend.length;
-    }
-
-    key(index: number): string | null {
-        return this.backend.key(index);
-    }
-
-    setItem(key: string, value: string): void {
-        if (!value || value.length === undefined || value.length === 0) {
-            this.writeStringToKey(key, "");
-            return;
-        }
-
-        let offset = 0;
-        while (offset < value.length) {
-            let substr = value.substr(offset, MAX_VALUE_SIZE);
-            offset += substr.length;
-
-            if (offset < value.length) {
-                substr += NEXT_PART_SYMBOL;
-            }
-
-            this.writeStringToKey(key, substr);
-            key += NEXT_PART_SYFFIX;
-        }
-    }
-
-    getItem(key: string): string | null {
-        let value = this.readStringFromKey(key);
-        if (value === null) {
-            return null;
-        }
-
-        if (value.length === 0) {
-            return value;
-        }
-
-        while (value[value.length - 1] === NEXT_PART_SYMBOL) {
-            value = value.substr(0, value.length - 1);
-            key += NEXT_PART_SYFFIX;
-            const next = this.readStringFromKey(key);
-            value += next === null ? "" : next;
-        }
-
-        return value;
-    }
-
-    removeItem(key: string): void {
-        this.backend.removeItem(this.prefix + key);
-        this.length = this.backend.length;
-    }
-
-    private writeStringToKey(key: string, value: string) {
-        this.backend.setItem(this.prefix + key, value);
-        this.length = this.backend.length;
-    }
-
-    private readStringFromKey(key: string) {
-        return this.backend.getItem(this.prefix + key);
-    }
-}
-
-export const lStorage = new LStorage(undefined, "jsdos.8.");