js-dos 7.5.0 → 8.1.1

package/src/window/window.css

@@ -0,0 +1,78 @@
+.jsdos-rso {
+  .window {
+    @apply overflow-hidden;
+
+    .background-image {
+      @apply absolute left-12 right-0 h-full pointer-events-none;
+      background-position: center;
+      background-size: cover;
+      background-repeat: no-repeat;
+      &::after {
+        position: relative;
+        content: "";
+        display: block;
+        width: 100%;
+        height: 100%;
+        background-color: hsl(var(--b1)/var(--tw-bg-opacity));
+        opacity: 0.75;
+      }
+    }
+
+    .play-button {
+      &:hover {
+        color: hsl(var(--af));
+      }
+    }
+
+    .dhry2-window {
+      @apply absolute left-0 top-0 w-full h-full flex flex-col items-center justify-center;
+      @apply bg-black bg-opacity-80 text-2xl px-8 py-4 text-white;
+
+      .title {
+        @apply mb-4 text-center text-4xl;
+      }
+
+      .backend {
+        @apply mb-8 text-center;
+      }
+
+      .results {
+        @apply grid grid-cols-2 gap-4;
+
+        div:nth-child(even) {
+          @apply text-green-300;
+
+          span {
+            @apply text-white;
+          }
+        }
+
+        div:nth-child(2),
+        div:last-child {
+          @apply text-yellow-300;
+        }
+
+      }
+    }
+
+    .pre-run-window {
+      @apply overflow-x-hidden overflow-y-auto flex-grow flex flex-col items-center justify-center px-8 m-auto;
+
+      .slider {
+        @apply justify-center w-80 max-w-none;
+
+        .label {
+          @apply flex-grow;
+        }
+
+        .touch {
+          @apply w-40 flex-grow-0;
+        }
+      }
+    }
+
+    .select-window {
+      @apply m-auto;
+    }
+  }
+}

package/src/window/window.tsx

@@ -0,0 +1,49 @@
+import { useSelector } from "react-redux";
+import { State } from "../store";
+import { DosWindow } from "./dos/dos-window";
+import { ErrorWindow } from "./error-window";
+import { LoadingWindow } from "./loading-window";
+import { PreRunWindow } from "./prerun-window";
+import { SelectWindow } from "./select-window";
+
+export function Window(props: {}) {
+    const frameOpened = useSelector((state: State) => state.ui.frame) !== "none";
+    const frameXs = useSelector((state: State) => state.ui.frameXs);
+    const window = useSelector((state: State) => state.ui.window);
+    const background = useSelector((state: State) => state.ui.background);
+
+    let windowComponent = <Loading />;
+    switch (window) {
+        case "error": {
+            windowComponent = <ErrorWindow />;
+        } break;
+        case "loading": {
+            windowComponent = <LoadingWindow />;
+        } break;
+        case "prerun": {
+            windowComponent = <PreRunWindow />;
+        } break;
+        case "run": {
+            windowComponent = <DosWindow />;
+        } break;
+        case "select": {
+            windowComponent = <SelectWindow />;
+        } break;
+        default: ;
+    };
+
+    return <div class="window absolute w-full h-full bg-base-100">
+        <div class="background-image"
+            style={{ backgroundImage: (background ? "url(" + background + ")" : undefined ) }} />
+        <div class="relative flex flex-row h-full w-full items-start justify-start overflow-auto">
+            <div class={(frameOpened ? (frameXs ? "w-24" : "w-96") : "w-12") + " flex-shrink-0"}></div>
+            {windowComponent}
+        </div>
+    </div>;
+}
+
+function Loading() {
+    return <div class="w-full h-full flex justify-center items-center">
+        <div class="radial-progress animate-spin" style="--value:70;"></div>
+    </div>;
+}

package/src/ws/ws-sockdrive.ts

@@ -0,0 +1,123 @@
+import { Handle, Stats } from "../sockdrive/js/src/sockdrive/types";
+import { Drive } from "../sockdrive/js/src/sockdrive/drive";
+
+interface Template {
+    name: string,
+    size: number,
+    heads: number,
+    cylinders: number,
+    sectors: number,
+    sectorSize: number,
+}
+
+export interface ReadResponse {
+    buffer?: Uint8Array,
+    code: number,
+}
+
+export function createSockdrive(
+    onOpen: (drive: string, read: boolean, write: boolean, imageSize: number, preloadQueue: number[]) => void,
+    onError: (e: Error) => void,
+    onPreloadProgress: (drive: string, restBytes: number) => void,
+) {
+    let seq = 0;
+    const mapping: { [handle: Handle]: Drive } = {};
+    const templates: { [handle: number]: Template } = {};
+    const memory: { [handle: number]: Uint8Array } = {};
+    const stats: Stats = {
+        read: 0,
+        write: 0,
+        readTotalTime: 0,
+        cacheHit: 0,
+        cacheMiss: 0,
+        cacheUsed: 0,
+    };
+    const sockdrive = {
+        stats,
+        open: async (url: string, owner: string, name: string, token: string): Promise<{
+            handle: Handle,
+            aheadRange: number,
+        }> => {
+            const response = await fetch(url.replace("wss://", "https://")
+                .replace("ws://", "http://") + "/template/" + owner + "/" + name);
+            const template = await response.json();
+            if (template.error) {
+                throw new Error(template.error);
+            }
+            seq++;
+            templates[seq] = {
+                name: template.name,
+                size: template.size ?? 0,
+                heads: template.heads ?? 1,
+                cylinders: template.cylinders ?? 520,
+                sectors: template.sectors ?? 63,
+                sectorSize: template.sector_size ?? 512,
+            };
+
+            const sectorSize = templates[seq].sectorSize;
+            const module = { HEAPU8: new Uint8Array(0) };
+            mapping[seq] = new Drive(url, owner, name, token, stats, module, true, true);
+            return new Promise<{ handle: Handle, aheadRange: number }>((resolve, reject) => {
+                const drive = owner + "/" + name;
+                mapping[seq].onOpen((read, write, imageSize, preloadQueue, aheadRange) => {
+                    memory[seq] = new Uint8Array(sectorSize /* write */ + sectorSize * aheadRange);
+                    module.HEAPU8 = memory[seq];
+                    onOpen(drive, read, write, imageSize, preloadQueue);
+                    resolve({
+                        handle: seq,
+                        aheadRange,
+                    });
+                });
+                mapping[seq].onPreloadProgress((restBytes) => {
+                    onPreloadProgress(drive, restBytes);
+                });
+                mapping[seq].onError((e) => {
+                    onError(e);
+                    reject(e);
+                });
+            });
+        },
+        read: async (handle: Handle, sector: number): Promise<ReadResponse> => {
+            if (mapping[handle]) {
+                const ptr = templates[seq].sectorSize;
+                let code = mapping[handle].read(sector, ptr, true) as number;
+                if (code = 255) {
+                    code = await mapping[handle].read(sector, ptr, false);
+                }
+                return {
+                    code,
+                    buffer: memory[handle].slice(ptr),
+                };
+            }
+
+            console.error("ERROR! sockdrive handle", handle, "not found");
+            return Promise.resolve({ code: 1 });
+        },
+        write: (handle: Handle, sector: number, buffer: Uint8Array): number => {
+            if (buffer.byteLength != templates[handle].sectorSize) {
+                onError(new Error("sockdrive write buffer size " + buffer.byteLength +
+                    " != sector size " + templates[handle].sectorSize));
+                return 1;
+            }
+            if (mapping[handle]) {
+                memory[handle].set(buffer, 0);
+                return mapping[handle].write(sector, 0);
+            }
+            console.error("ERROR! sockdrive handle", handle, "not found");
+            return 1;
+        },
+        close: (handle: Handle) => {
+            if (mapping[handle]) {
+                mapping[handle].close();
+                delete memory[handle];
+                delete templates[handle];
+                delete mapping[handle];
+            }
+        },
+        template: (handle: Handle) => {
+            return templates[handle];
+        },
+    };
+
+    return sockdrive;
+}