glimpse-sdk 0.8.0 → 0.9.0

package/dist/reconciler.js

@@ -0,0 +1,583 @@
+import fs from "node:fs";
+import { createInterface } from "node:readline";
+import { inspect } from "node:util";
+import Reconciler from "react-reconciler";
+import { DefaultEventPriority } from "react-reconciler/constants.js";
+const TEXT = new Set(["label", "indicator", "button", "progress"]);
+const SKIP = new Set(["children", "key", "ref"]);
+const encoder = new TextEncoder();
+function createStore(initial) {
+    let value = initial;
+    const listeners = new Set();
+    return {
+        get: () => value,
+        set(next) {
+            if (Object.is(next, value))
+                return;
+            value = next;
+            for (const listener of [...listeners])
+                listener();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}
+export const optionsStore = createStore({});
+export const placementStore = createStore(null);
+export const nameStore = createStore("");
+export const stateStore = createStore("");
+export const openStore = createStore(false);
+class ProtocolLimitError extends Error {
+    name = "ProtocolLimitError";
+}
+function writeAll(fd, text) {
+    const bytes = encoder.encode(text);
+    const pause = new Int32Array(new SharedArrayBuffer(4));
+    for (let offset = 0; offset < bytes.length;) {
+        try {
+            const written = fs.writeSync(fd, bytes, offset, bytes.length - offset);
+            if (written === 0)
+                throw new Error("zero-byte write");
+            offset += written;
+        }
+        catch (error) {
+            if (error.code !== "EAGAIN")
+                throw error;
+            Atomics.wait(pause, 0, 0, 2);
+        }
+    }
+}
+function lineOf(message) {
+    const line = JSON.stringify(message);
+    if (encoder.encode(line).byteLength > 1_048_576) {
+        throw new ProtocolLimitError("outgoing line exceeds 1 MiB");
+    }
+    return line;
+}
+let emit = (message) => writeAll(1, `${lineOf(message)}\n`);
+let helloWritten = false;
+const queued = [];
+export function setEmit(write) {
+    emit = write;
+}
+export function send(message) {
+    if (helloWritten)
+        emit(message);
+    else
+        queued.push(message);
+}
+const consoleMethods = [
+    "log",
+    "info",
+    "debug",
+    "dir",
+    "dirxml",
+    "table",
+    "count",
+    "countReset",
+    "time",
+    "timeLog",
+    "timeEnd",
+    "group",
+    "groupCollapsed",
+    "groupEnd",
+    "trace",
+];
+const originalConsole = new Map();
+function writeStderr(...args) {
+    const text = args.map((value) => {
+        if (typeof value === "string")
+            return value;
+        return inspect(value);
+    }).join(" ");
+    writeAll(2, `${text}\n`);
+}
+export function redirectConsole() {
+    const target = console;
+    if (originalConsole.size)
+        return;
+    for (const method of consoleMethods) {
+        originalConsole.set(method, target[method]);
+        target[method] = writeStderr;
+    }
+}
+export function restoreConsole() {
+    const target = console;
+    for (const [method, original] of originalConsole)
+        target[method] = original;
+    originalConsole.clear();
+}
+const reconcilerFactory = Reconciler;
+const eventPriority = DefaultEventPriority ?? 32;
+async function loadReconciler() {
+    return reconcilerFactory;
+}
+function textOf(children) {
+    const values = [children].flat(Infinity).filter((child) => child !== null && child !== undefined && typeof child !== "boolean");
+    return values.length &&
+        values.every((child) => typeof child === "string" || typeof child === "number")
+        ? values.join("")
+        : undefined;
+}
+function capped(value, limit) {
+    return [...value].slice(0, limit).join("");
+}
+function wireProps(type, props) {
+    const out = {};
+    const text = TEXT.has(type) ? textOf(props.children) : undefined;
+    for (const key of Object.keys(props)) {
+        if (SKIP.has(key))
+            continue;
+        if (key === "text") {
+            if (text !== undefined)
+                out.text = capped(text, 256);
+            else if (typeof props.text === "string" || typeof props.text === "number") {
+                out.text = capped(String(props.text), 256);
+            }
+            continue;
+        }
+        if (!Object.hasOwn(props, key))
+            continue;
+        const value = props[key];
+        if (typeof value === "function") {
+            out[key] = true;
+            continue;
+        }
+        if (value === undefined)
+            continue;
+        out[key] = typeof value === "string"
+            ? capped(value, key === "badge" ? 8 : type === "entry" && key === "value" ? 4096 : 256)
+            : value;
+    }
+    if (text !== undefined && !Object.hasOwn(out, "text")) {
+        out.text = capped(text, 256);
+    }
+    return out;
+}
+function same(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (left === null || right === null)
+        return false;
+    if (typeof left !== "object" || typeof right !== "object")
+        return false;
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function diffProps(type, prev, next) {
+    const before = wireProps(type, prev);
+    const after = wireProps(type, next);
+    const seen = new Set();
+    const out = {};
+    let changed = false;
+    for (const key of [...Object.keys(after), ...Object.keys(before)]) {
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const hasBefore = Object.hasOwn(before, key);
+        const hasAfter = Object.hasOwn(after, key);
+        if (!hasBefore && !hasAfter)
+            continue;
+        if (hasBefore && hasAfter && same(before[key], after[key]))
+            continue;
+        out[key] = hasAfter ? after[key] : null;
+        changed = true;
+    }
+    return changed ? out : null;
+}
+function bindHandlers(node, props) {
+    node.handlers = new Map();
+    for (const [key, value] of Object.entries(props)) {
+        if (typeof value === "function")
+            node.handlers.set(key, value);
+    }
+}
+function blankNode(type) {
+    return {
+        id: 0,
+        type,
+        props: {},
+        children: [],
+        attached: false,
+        handlers: new Map(),
+    };
+}
+function serialize(session, node) {
+    if (node.id === 0)
+        node.id = session.nextId++;
+    node.attached = true;
+    session.nodes.set(node.id, node);
+    return {
+        id: node.id,
+        type: node.type,
+        props: node.props,
+        children: node.children.map((child) => serialize(session, child)),
+    };
+}
+function forget(session, node) {
+    session.nodes.delete(node.id);
+    for (const child of node.children)
+        forget(session, child);
+    node.children = [];
+    node.handlers.clear();
+    node.attached = false;
+}
+function place(session, parent, child, before) {
+    const existing = parent.children.indexOf(child);
+    if (existing >= 0)
+        parent.children.splice(existing, 1);
+    const index = before
+        ? parent.children.indexOf(before)
+        : parent.children.length;
+    parent.children.splice(index < 0 ? parent.children.length : index, 0, child);
+    if (child.attached) {
+        session.ops.push({
+            op: "move",
+            parent: parent.id,
+            id: child.id,
+            before: before ? before.id : null,
+        });
+        return;
+    }
+    session.ops.push({
+        op: "insert",
+        parent: parent.id,
+        before: before ? before.id : null,
+        node: serialize(session, child),
+    });
+}
+function unplace(session, parent, child) {
+    const index = parent.children.indexOf(child);
+    if (index >= 0)
+        parent.children.splice(index, 1);
+    if (child.attached && child.id !== 0) {
+        session.ops.push({ op: "remove", parent: parent.id, id: child.id });
+    }
+    forget(session, child);
+}
+function makeHost(session) {
+    let priority = eventPriority;
+    return {
+        supportsMutation: true,
+        supportsPersistence: false,
+        supportsHydration: false,
+        isPrimaryRenderer: true,
+        noTimeout: -1,
+        scheduleTimeout: setTimeout,
+        cancelTimeout: clearTimeout,
+        supportsMicrotasks: true,
+        scheduleMicrotask: queueMicrotask,
+        getRootHostContext: () => ({}),
+        getChildHostContext: (context) => context,
+        getPublicInstance: (instance) => instance,
+        shouldSetTextContent: (type, props) => TEXT.has(type) && textOf(props.children) !== undefined,
+        createInstance(type, props) {
+            const node = blankNode(type);
+            node.props = wireProps(type, props);
+            bindHandlers(node, props);
+            return node;
+        },
+        createTextInstance(text) {
+            const node = blankNode("label");
+            node.props = { text: capped(text, 256) };
+            return node;
+        },
+        appendInitialChild: (parent, child) => {
+            parent.children.push(child);
+        },
+        appendChild: (parent, child) => place(session, parent, child, null),
+        appendChildToContainer: (parent, child) => place(session, parent, child, null),
+        insertBefore: (parent, child, before) => place(session, parent, child, before),
+        insertInContainerBefore: (parent, child, before) => place(session, parent, child, before),
+        removeChild: (parent, child) => unplace(session, parent, child),
+        removeChildFromContainer: (parent, child) => unplace(session, parent, child),
+        commitUpdate(node, _type, prev, next) {
+            bindHandlers(node, next);
+            const diff = diffProps(node.type, prev, next);
+            if (!diff)
+                return;
+            const op = {
+                op: "set",
+                id: node.id,
+                props: diff,
+            };
+            const controlled = CONTROLLED[node.type]?.[1];
+            if (node.confirmSeq !== undefined && controlled &&
+                Object.hasOwn(diff, controlled)) {
+                op.seq = node.confirmSeq;
+                node.confirmSeq = undefined;
+            }
+            node.props = wireProps(node.type, next);
+            session.ops.push(op);
+        },
+        finalizeInitialChildren: () => false,
+        prepareForCommit: () => null,
+        resetAfterCommit() {
+            session.pending.push(...session.ops);
+            session.ops = [];
+        },
+        clearContainer: () => { },
+        detachDeletedInstance: () => { },
+        preparePortalMount: () => { },
+        getCurrentEventPriority: () => eventPriority,
+        setCurrentUpdatePriority: (next) => {
+            priority = next;
+        },
+        getCurrentUpdatePriority: () => priority,
+        resolveUpdatePriority: () => priority || eventPriority,
+        shouldAttemptEagerTransition: () => false,
+        maySuspendCommit: () => false,
+        maySuspendCommitOnUpdate: () => false,
+        maySuspendCommitInSyncRender: () => false,
+        preloadInstance: () => true,
+        startSuspendingCommit: () => { },
+        suspendInstance: () => { },
+        waitForCommitToBeReady: () => null,
+        requestPostPaintCallback: () => { },
+        trackSchedulerEvent: () => { },
+        resolveEventType: () => null,
+        resolveEventTimeStamp: () => -1.1,
+        NotPendingTransition: null,
+        HostTransitionContext: {
+            $$typeof: Symbol.for("react.context"),
+            _currentValue: null,
+            _currentValue2: null,
+        },
+        resetFormInstance: () => { },
+        commitMount: () => { },
+        commitTextUpdate(node, _previous, next) {
+            const text = capped(next, 256);
+            if (node.props.text === text)
+                return;
+            node.props.text = text;
+            session.ops.push({ op: "set", id: node.id, props: { text } });
+        },
+        resetTextContent: () => { },
+        hideInstance: () => { },
+        hideTextInstance: () => { },
+        unhideInstance: () => { },
+        unhideTextInstance: () => { },
+    };
+}
+const CONTROLLED = {
+    entry: ["onChange", "value"],
+    fader: ["onChange", "value"],
+    scale: ["onChange", "value"],
+    switch: ["onToggle", "active"],
+    switchrow: ["onToggle", "active"],
+};
+let current = null;
+function flush(session, fn, emitCommit = true) {
+    session.reconciler.flushSyncFromReconciler(fn);
+    session.reconciler["flushPassiveEffects"]?.();
+    for (const node of session.nodes.values()) {
+        const controlled = CONTROLLED[node.type]?.[1];
+        if (node.confirmSeq === undefined || !controlled)
+            continue;
+        session.pending.push({
+            op: "set",
+            id: node.id,
+            props: { [controlled]: (node.props[controlled] ?? null) },
+            seq: node.confirmSeq,
+        });
+        node.confirmSeq = undefined;
+    }
+    let count = 0;
+    const visit = (node) => {
+        if (++count > 300)
+            throw new ProtocolLimitError("tree exceeds 300 nodes");
+        if (node.children.length > 200) {
+            throw new ProtocolLimitError("parent exceeds 200 children");
+        }
+        for (const child of node.children)
+            visit(child);
+    };
+    visit(session.container);
+    if (session.pending.length > 1200) {
+        throw new ProtocolLimitError("commit exceeds 1200 operations");
+    }
+    if (emitCommit && session.pending.length) {
+        send({ t: "commit", ops: session.pending });
+        session.pending = [];
+    }
+}
+async function mountFresh(element) {
+    const factory = await loadReconciler();
+    const container = blankNode("root");
+    container.id = 0;
+    container.attached = true;
+    const session = {
+        nextId: 1,
+        nodes: new Map(),
+        ops: [],
+        pending: [],
+        container,
+        reconciler: null,
+        root: null,
+    };
+    session.reconciler = factory(makeHost(session));
+    session.root = session.reconciler.createContainer(container, 0, null, false, null, "applet", (error) => {
+        console.error(error);
+        process.exit(70);
+    }, (error) => {
+        console.error(error);
+    }, (error) => {
+        console.error(error);
+    }, null);
+    current = session;
+    flush(session, () => {
+        session.reconciler.updateContainer(element, session.root, null, null);
+    }, false);
+}
+function dispatchEvent(message) {
+    if (message.t !== "event" || !current)
+        return;
+    const id = message.id;
+    if (typeof id !== "number")
+        return;
+    const node = current.nodes.get(id);
+    if (!node)
+        return;
+    if (typeof message.name !== "string")
+        return;
+    const handler = node.handlers.get(message.name);
+    if (!handler)
+        return;
+    if (CONTROLLED[node.type]?.[0] === message.name &&
+        typeof message.seq === "number" && Number.isFinite(message.seq)) {
+        if (node.appliedSeq !== undefined && message.seq < node.appliedSeq)
+            return;
+        node.appliedSeq = message.seq;
+        node.confirmSeq = message.seq;
+    }
+    const args = Array.isArray(message.args) ? message.args : [];
+    try {
+        handler(...args);
+    }
+    catch (error) {
+        console.error(error);
+        process.exit(1);
+    }
+}
+function apply(message) {
+    if (!current)
+        return;
+    if (message.t === "options") {
+        optionsStore.set(message.options ?? {});
+        return;
+    }
+    if (message.t === "placement") {
+        placementStore.set(message.placement ?? null);
+        return;
+    }
+    if (message.t === "popover") {
+        openStore.set(message.open === true);
+        return;
+    }
+    if (message.t === "event")
+        dispatchEvent(message);
+}
+export async function session(element, io) {
+    redirectConsole();
+    await loadReconciler();
+    current = null;
+    helloWritten = false;
+    setEmit((message) => io.writeLine(lineOf(message)));
+    io.writeLine(lineOf({ t: "hello", v: 1 }));
+    helloWritten = true;
+    for (const message of queued.splice(0))
+        emit(message);
+    for await (const chunk of io.lines) {
+        try {
+            const buffered = [];
+            for (const line of Array.isArray(chunk) ? chunk : [chunk]) {
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch (error) {
+                    console.error(error);
+                    continue;
+                }
+                if (!message || typeof message !== "object" ||
+                    typeof message.t !== "string")
+                    continue;
+                if (message.t === "hello") {
+                    if (current)
+                        continue;
+                    if (message.v !== 1) {
+                        console.error(`unsupported host protocol version: ${message.v}`);
+                        process.exit(1);
+                        return;
+                    }
+                    optionsStore.set(message.options ?? {});
+                    placementStore.set(message.placement ?? null);
+                    nameStore.set(typeof message.name === "string" ? message.name : "");
+                    stateStore.set(typeof message.state === "string" ? message.state : "");
+                    openStore.set(false);
+                    await mountFresh(element);
+                    continue;
+                }
+                if (current)
+                    buffered.push(message);
+            }
+            if (current) {
+                flush(current, () => {
+                    for (const message of buffered)
+                        apply(message);
+                });
+            }
+        }
+        catch (error) {
+            if (!(error instanceof ProtocolLimitError))
+                throw error;
+            console.error(error);
+            process.exit(70);
+            return;
+        }
+    }
+}
+export async function* stdinLines(input = process.stdin) {
+    const reader = createInterface({ input, crlfDelay: Infinity });
+    const pending = [];
+    const batches = [];
+    let wake;
+    let closed = false;
+    reader.on("line", (line) => {
+        if (line.trim() === "")
+            return;
+        pending.push(line);
+        if (pending.length === 1) {
+            setImmediate(() => {
+                batches.push(pending.splice(0));
+                wake?.();
+                wake = undefined;
+            });
+        }
+    });
+    reader.on("close", () => {
+        closed = true;
+        wake?.();
+        wake = undefined;
+    });
+    try {
+        while (!closed || pending.length || batches.length) {
+            if (!batches.length)
+                await new Promise((resolve) => { wake = resolve; });
+            while (batches.length)
+                yield batches.shift();
+        }
+    }
+    finally {
+        reader.close();
+    }
+}
+export function standardIo() {
+    return {
+        writeLine(line) {
+            writeAll(1, `${line}\n`);
+        },
+        lines: stdinLines(),
+    };
+}

package/package.json

@@ -1,53 +1,54 @@
 {
   "name": "glimpse-sdk",
-  "version": "0.8.0",
-  "description": "Typed async framework for building Glimpse exec applets",
-  "type": "module",
-  "main": "dist/src/index.js",
-  "types": "dist/src/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/src/index.js"
-    }
-  },
-  "files": [
-    "dist/src",
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "npm run build && node --test dist/tests/*.test.js",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "glimpse",
-    "applet",
-    "panel",
-    "desktop",
-    "sdk"
-  ],
-  "license": "MIT",
-  "author": "Alex Oleshkevich <alex.oleshkevich@gmail.com>",
-  "homepage": "https://alex-oleshkevich.github.io/glimpse/",
+  "version": "0.9.0",
+  "description": "React renderer for glimpse panel applets: write the indicator and popover in JSX, run it under Node.",
+  "keywords": ["glimpse", "applet", "panel", "wayland", "react"],
+  "license": "BSD-3-Clause",
+  "author": "Alex Oleshkevich",
+  "homepage": "https://github.com/alex-oleshkevich/glimpse/tree/master/sdk/applet#readme",
+  "bugs": "https://github.com/alex-oleshkevich/glimpse/issues",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/alex-oleshkevich/glimpse.git",
-    "directory": "sdk/sdk-ts"
-  },
-  "bugs": {
-    "url": "https://github.com/alex-oleshkevich/glimpse/issues"
+    "directory": "sdk/applet"
   },
+  "type": "module",
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./jsx-runtime": {
+      "types": "./dist/jsx-runtime.d.ts",
+      "default": "./dist/jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./dist/jsx-runtime.d.ts",
+      "default": "./dist/jsx-runtime.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": ["dist", "PROTOCOL.md"],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check": "tsc --noEmit",
+    "test": "node --test",
+    "prepack": "npm run build"
   },
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@types/react": "19.3.0",
+    "@types/react-reconciler": "0.33.1",
+    "react": "19.3.0",
+    "react-reconciler": "0.34.0"
+  },
   "devDependencies": {
-    "@types/node": "^20.14.0",
-    "typescript": "^5.6.0"
+    "@types/node": "26.6.3",
+    "typescript": "7.0.2"
   }
 }