@isothrum/editor 0.0.0-stage → 0.1.0

package/styles/theme.css

@@ -0,0 +1,192 @@
+/*
+ * ─────────────────────────────────────────────────────────────────────────────
+ *  THEME — the one file to edit to rebrand the site.
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ *  Three layers, each built only from the one above it:
+ *
+ *   1. Palettes   --brand-*, --base-*   → point at a Tailwind color scale.
+ *   2. Semantic   --primary, --border…  → what components use (shadcn contract).
+ *   3. Utilities  bg-primary, text-muted-foreground…  (wired in globals.css).
+ *
+ *  Quick recipes
+ *   • New brand color:  replace `indigo` below with any Tailwind scale
+ *                       (violet, blue, emerald, rose, orange…).
+ *   • Warmer/cooler UI: replace `zinc` with neutral, slate, gray or stone.
+ *   • Rounder/sharper:  change --radius (0 = square, 1rem = pill-ish).
+ *   • Fonts:            lib/fonts.ts.
+ *   • Logo / favicon / OG colors: lib/brand.ts (mirror the hex values).
+ *
+ *  Components should only ever use semantic tokens (bg-primary, text-muted-
+ *  foreground, border…) or the brand scale (bg-brand-50) — never raw palette
+ *  classes like bg-indigo-600 — so a palette swap here restyles everything.
+ */
+
+:root {
+  /* 1. Palettes ------------------------------------------------------------ */
+  /* Excalidraw-style violet (500 is #6965db). */
+  --brand-50: #f3f2ff;
+  --brand-100: #e9e8ff;
+  --brand-200: #d4d2fc;
+  --brand-300: #b5b2f6;
+  --brand-400: #a8a5ff;
+  --brand-500: #6965db;
+  --brand-600: #5b57d1;
+  --brand-700: #4a47b1;
+  --brand-800: #3d3a91;
+  --brand-900: #2f2d70;
+  --brand-950: #1d1b45;
+
+  --base-50: var(--color-zinc-50);
+  --base-100: var(--color-zinc-100);
+  --base-200: var(--color-zinc-200);
+  --base-300: var(--color-zinc-300);
+  --base-400: var(--color-zinc-400);
+  --base-500: var(--color-zinc-500);
+  --base-600: var(--color-zinc-600);
+  --base-700: var(--color-zinc-700);
+  --base-800: var(--color-zinc-800);
+  --base-900: var(--color-zinc-900);
+  --base-950: var(--color-zinc-950);
+
+  /* Shape, layout & type */
+  /* Soft corners: clear, a little playful. */
+  --radius: 0.75rem;
+  /* Max width of `.container` (header, pages, footer). */
+  --content-width: 72rem;
+  /* Geist needs no character variants. */
+  --font-features: normal;
+
+  /* 2. Semantic tokens — light --------------------------------------------- */
+  --background: var(--color-white);
+  --foreground: var(--base-950);
+  /* Subtle alternate section background (feature bands, footers). */
+  /* Barely-there gray for bands and the editor's chrome, as on vercel.com. */
+  --surface: oklch(0.985 0 0);
+
+  --card: var(--color-white);
+  --card-foreground: var(--base-950);
+  --popover: var(--color-white);
+  --popover-foreground: var(--base-950);
+
+  /* Isothrum's identity: a white whiteboard, ink lines, soft violet for what you act on
+     and what is selected. 600 keeps white button text above 4.5:1. */
+  --primary: var(--brand-600);
+  --primary-foreground: var(--color-white);
+  --signal: var(--brand-500);
+  --signal-foreground: var(--brand-700);
+  /* Pastel fills for devices, as on a whiteboard. */
+  --pastel-blue: #e7f5ff;
+  --pastel-green: #ebfbee;
+  --pastel-yellow: #fff9db;
+  --pastel-violet: #f3f0ff;
+  --pastel-red: #fff0f0;
+  --secondary: var(--base-100);
+  --secondary-foreground: var(--base-900);
+  --muted: var(--base-100);
+  --muted-foreground: oklch(0.52 0 0);
+  --accent: var(--base-100);
+  --accent-foreground: var(--base-900);
+
+  /* Inline text links (prose, "link" buttons). */
+  --link: var(--brand-700);
+
+  --destructive: var(--color-red-600);
+  --success: var(--color-emerald-700);
+  --warning: var(--color-amber-500);
+  --info: var(--color-sky-600);
+
+  --border: oklch(0.922 0 0);
+  --input: oklch(0.9 0 0);
+  --ring: var(--brand-500);
+
+  --chart-1: var(--brand-500);
+  --chart-2: var(--color-sky-500);
+  --chart-3: var(--color-emerald-500);
+  --chart-4: var(--color-amber-500);
+  --chart-5: var(--color-rose-500);
+
+  --sidebar: var(--base-50);
+  --sidebar-foreground: var(--base-950);
+  --sidebar-primary: var(--primary);
+  --sidebar-primary-foreground: var(--primary-foreground);
+  --sidebar-accent: var(--base-100);
+  --sidebar-accent-foreground: var(--base-900);
+  --sidebar-border: var(--base-200);
+  --sidebar-ring: var(--ring);
+}
+
+/* 2b. Semantic tokens — dark ---------------------------------------------- */
+.dark {
+  /* Near-black with barely-raised surfaces, as on a lit rack at night. */
+  --background: oklch(0.145 0.003 286);
+  --foreground: var(--base-50);
+  --surface: oklch(0.17 0.003 286);
+
+  --card: oklch(0.185 0.004 286);
+  --card-foreground: var(--base-50);
+  --popover: oklch(0.2 0.004 286);
+  --popover-foreground: var(--base-50);
+
+  --primary: var(--brand-400);
+  --primary-foreground: var(--base-950);
+  --signal: var(--brand-400);
+  --signal-foreground: var(--brand-400);
+  --pastel-blue: oklch(0.3 0.04 240);
+  --pastel-green: oklch(0.3 0.04 150);
+  --pastel-yellow: oklch(0.32 0.04 95);
+  --pastel-violet: oklch(0.3 0.05 285);
+  --pastel-red: oklch(0.3 0.04 20);
+  --secondary: var(--base-800);
+  --secondary-foreground: var(--base-50);
+  --muted: var(--base-800);
+  --muted-foreground: var(--base-400);
+  --accent: var(--base-800);
+  --accent-foreground: var(--base-50);
+
+  --link: var(--brand-400);
+
+  --destructive: var(--color-red-500);
+  --success: var(--color-emerald-400);
+  --warning: var(--color-amber-400);
+  --info: var(--color-sky-400);
+
+  --border: oklch(1 0 0 / 10%);
+  --input: oklch(1 0 0 / 15%);
+  --ring: var(--brand-400);
+
+  --sidebar: var(--base-900);
+  --sidebar-foreground: var(--base-50);
+  --sidebar-accent: var(--base-800);
+  --sidebar-accent-foreground: var(--base-50);
+  --sidebar-border: oklch(1 0 0 / 10%);
+}
+
+/* The editor's business design: the canvas in the plain sans, with quiet fills, for a diagram
+   that goes into a report (the sketch design is the default above). */
+[data-design="business"] {
+  --font-brand-heading: var(--font-brand-sans);
+  /* Resolved at the root from the brand's heading font: said again here, for business. */
+  --font-heading: var(--font-sans);
+  --pastel-blue: oklch(0.975 0.006 250);
+  --pastel-green: oklch(0.975 0.006 160);
+  --pastel-yellow: oklch(0.98 0.008 95);
+  --pastel-violet: oklch(0.975 0.006 285);
+  --pastel-red: oklch(0.975 0.006 20);
+}
+.dark [data-design="business"] {
+  --pastel-blue: oklch(0.23 0.012 250);
+  --pastel-green: oklch(0.23 0.012 160);
+  --pastel-yellow: oklch(0.24 0.012 95);
+  --pastel-violet: oklch(0.23 0.012 285);
+  --pastel-red: oklch(0.23 0.012 20);
+}
+
+/* Business: connection points show on the device under the pointer (or selected) only, as in a
+   network diagram tool. */
+[data-design="business"] .react-flow__node:not(:hover):not(.selected) .react-flow__handle {
+  opacity: 0;
+}
+[data-design="business"] .react-flow__handle {
+  transition: opacity 120ms;
+}

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "./dist/types",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"],
+  "exclude": ["node_modules", "dist", "src/**/*.test.ts", "src/**/*.test.tsx", "src/test/**"]
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "skipLibCheck": true,
+    "types": ["node"],
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "scripts/**/*.mjs", "desktop-editor/**/*.tsx"],
+  "exclude": ["node_modules", "dist"]
+}

package/wasm/isothrum_wasm.d.ts

@@ -0,0 +1,60 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * The download: a zip with `isoloom.yml` and every generated file.
+ */
+export function bundle(topology_json: string): Uint8Array;
+
+/**
+ * The download for one target (see [`bundle_target_bytes`]).
+ */
+export function bundle_target(topology_json: string, target_dir: string): Uint8Array;
+
+/**
+ * JSON for the desktop app: [`own_files`].
+ */
+export function own_files_json(topology_json: string): string;
+
+/**
+ * JSON for the editor: a [`Plan`].
+ */
+export function plan_json(topology_json: string): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly bundle: (a: number, b: number) => [number, number, number, number];
+    readonly bundle_target: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+    readonly own_files_json: (a: number, b: number) => [number, number];
+    readonly plan_json: (a: number, b: number) => [number, number];
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/wasm/isothrum_wasm.js

@@ -0,0 +1,312 @@
+/* @ts-self-types="./isothrum_wasm.d.ts" */
+
+/**
+ * The download: a zip with `isoloom.yml` and every generated file.
+ *
+ * # Errors
+ *
+ * The [`EngineError`]'s message, as a JavaScript `Error`.
+ * @param {string} topology_json
+ * @returns {Uint8Array}
+ */
+export function bundle(topology_json) {
+    const ptr0 = passStringToWasm0(topology_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.bundle(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * The download for one target (see [`bundle_target_bytes`]).
+ *
+ * # Errors
+ *
+ * The [`EngineError`]'s message, as a JavaScript `Error`.
+ * @param {string} topology_json
+ * @param {string} target_dir
+ * @returns {Uint8Array}
+ */
+export function bundle_target(topology_json, target_dir) {
+    const ptr0 = passStringToWasm0(topology_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(target_dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.bundle_target(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+
+/**
+ * JSON for the editor: Isoloom's lists ([`Choices`]), what its OS, appliance and protocol
+ * fields offer.
+ * @returns {string}
+ */
+export function choices_json() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.choices_json();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * JSON for the desktop app: [`own_files`].
+ * @param {string} topology_json
+ * @returns {string}
+ */
+export function own_files_json(topology_json) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(topology_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.own_files_json(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * JSON for the editor: a [`Plan`].
+ * @param {string} topology_json
+ * @returns {string}
+ */
+export function plan_json(topology_json) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(topology_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.plan_json(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_30c8987f7c2ed4e2: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./isothrum_wasm_bg.js": import0,
+    };
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('isothrum_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };