@phreshos/client 0.1.0

package/dist/wire.js

@@ -0,0 +1,226 @@
+import Deadline from "./deadline.js";
+import { defaultTimeout } from "./events.js";
+import captureClientOutput from "./log.js";
+/** The client endpoint's sole postMessage adapter. */
+class Wire {
+    parent = window.parent === window ? null : window.parent;
+    pending = new Map();
+    subscribers = new Map();
+    every = new Map();
+    impossible = new Map();
+    boundarySubscriptions = new Map();
+    observations = new Map();
+    identity;
+    constructor() {
+        let identify = () => undefined;
+        this.identity = new Promise(resolve => { identify = resolve; });
+        this.send("boundary", "document", crypto.randomUUID());
+        this.send("boundary", "identity");
+        window.addEventListener("message", event => {
+            if (event.source !== this.parent || !Array.isArray(event.data))
+                return;
+            const [route, ...values] = event.data;
+            if (route === "boundary") {
+                const [operation, ...rest] = values;
+                if (operation === "identity" && typeof rest[0] === "string")
+                    identify(rest[0]);
+                if (operation === "impossible" && typeof rest[0] === "string" && typeof rest[1] === "string") {
+                    this.impossible.get(rest[0])?.(new Error(rest[1]));
+                    this.impossible.delete(rest[0]);
+                }
+                return;
+            }
+            if (route === "host-end" && values[0] === "observations-ready") {
+                for (const [subscription, description] of this.boundarySubscriptions) {
+                    this.send("boundary", "subscribe", subscription, ...description);
+                }
+                for (const [subscription, description] of this.observations) {
+                    this.send("end-host", "observe", subscription, ...description);
+                }
+                return;
+            }
+            if (values[0] === "answer" && typeof values[1] === "string") {
+                this.settle(values[1], values.at(-1));
+                return;
+            }
+            this.deliver(route, values);
+        });
+    }
+    send(route, ...values) {
+        this.parent?.postMessage([route, ...values], "*");
+    }
+    request(values, timeout = defaultTimeout, transfer = []) {
+        return this.question("end-host", values, timeout, transfer);
+    }
+    requestWithin(values, deadline, transfer = []) {
+        return this.question("end-host", values, deadline.remaining(), transfer, deadline.milliseconds);
+    }
+    askServerWithin(event, payload, deadline) {
+        return this.question("end-end", [event, payload], deadline.remaining(), [], deadline.milliseconds);
+    }
+    question(route, values, timeout, transfer = [], reportedTimeout = timeout) {
+        return new Promise((resolve, reject) => {
+            let active = true;
+            let question = null;
+            const timer = setTimeout(() => {
+                if (!active)
+                    return;
+                active = false;
+                if (question) {
+                    this.pending.delete(question);
+                    this.send("boundary", "forget", question);
+                }
+                reject(new Error(`Answer timeout ${reportedTimeout}ms`));
+            }, timeout);
+            this.identity.then(identity => {
+                if (!active)
+                    return;
+                question = `client:${identity}:${crypto.randomUUID()}`;
+                const publicId = crypto.randomUUID();
+                this.send("boundary", "expect", question);
+                this.pending.set(question, {
+                    timer,
+                    resolve: value => {
+                        if (!active)
+                            return;
+                        active = false;
+                        resolve(value);
+                    },
+                    reject: error => {
+                        if (!active)
+                            return;
+                        active = false;
+                        reject(error);
+                    }
+                });
+                const message = route === "end-end"
+                    ? [route, "wait", question, publicId, ...values]
+                    : [route, "wait", question, ...values];
+                try {
+                    this.parent?.postMessage(message, "*", transfer);
+                }
+                catch (error) {
+                    this.pending.delete(question);
+                    this.send("boundary", "forget", question);
+                    clearTimeout(timer);
+                    active = false;
+                    reject(error);
+                }
+            });
+        });
+    }
+    expectWithin(question, deadline) {
+        this.send("boundary", "expect", question);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(question);
+                this.send("boundary", "forget", question);
+                reject(new Error(`Answer timeout ${deadline.milliseconds}ms`));
+            }, deadline.remaining());
+            this.pending.set(question, { resolve, reject, timer });
+        });
+    }
+    forget(question) {
+        const pending = this.pending.get(question);
+        if (pending)
+            clearTimeout(pending.timer);
+        this.pending.delete(question);
+        this.send("boundary", "forget", question);
+    }
+    on(route, event, handler, subject = null, impossible) {
+        const key = `${route}:${event}`;
+        const handlers = this.subscribers.get(key) ?? new Set();
+        handlers.add(handler);
+        this.subscribers.set(key, handlers);
+        const subscription = this.register("publish", route, event, subject, impossible);
+        return once(() => {
+            handlers.delete(handler);
+            if (!handlers.size)
+                this.subscribers.delete(key);
+            this.unregister(subscription);
+        });
+    }
+    onAll(route, handler, subject = null) {
+        const handlers = this.every.get(route) ?? new Set();
+        handlers.add(handler);
+        this.every.set(route, handlers);
+        const subscription = this.register("publish", route, null, subject);
+        return once(() => {
+            handlers.delete(handler);
+            if (!handlers.size)
+                this.every.delete(route);
+            this.unregister(subscription);
+        });
+    }
+    observe(target, half, kind, event, handler, impossible) {
+        const subscription = crypto.randomUUID();
+        const stop = this.on("observed", subscription, handler);
+        const description = [target, half, kind, event, impossible !== undefined];
+        this.observations.set(subscription, description);
+        if (impossible)
+            this.impossible.set(subscription, impossible);
+        this.send("end-host", "observe", subscription, ...description);
+        return once(() => {
+            stop();
+            this.observations.delete(subscription);
+            this.impossible.delete(subscription);
+            this.send("end-host", "unobserve", subscription);
+        });
+    }
+    samplePointer(movementX, movementY) {
+        this.send("end-host", "pointerSample", movementX, movementY);
+    }
+    register(kind, route, event, subject, impossible) {
+        const subscription = crypto.randomUUID();
+        const description = [kind, route, event, subject, impossible !== undefined];
+        this.boundarySubscriptions.set(subscription, description);
+        if (impossible)
+            this.impossible.set(subscription, impossible);
+        this.send("boundary", "subscribe", subscription, ...description);
+        return subscription;
+    }
+    unregister(subscription) {
+        if (!this.boundarySubscriptions.delete(subscription))
+            return;
+        this.impossible.delete(subscription);
+        this.send("boundary", "unsubscribe", subscription);
+    }
+    deliver(route, values) {
+        const [event, ...message] = values;
+        if (typeof event !== "string")
+            return;
+        for (const handler of [...this.subscribers.get(`${route}:${event}`) ?? []])
+            invoke(handler, message);
+        for (const observer of [...this.every.get(route) ?? []])
+            invoke(observer, [event, ...message]);
+    }
+    settle(question, outcome) {
+        const pending = this.pending.get(question);
+        if (!pending)
+            return;
+        this.pending.delete(question);
+        clearTimeout(pending.timer);
+        this.send("boundary", "forget", question);
+        if (outcome?.success === true)
+            pending.resolve(outcome.result);
+        else if (outcome?.success === false && typeof outcome.error === "string")
+            pending.reject(new Error(outcome.error));
+        else
+            pending.reject(new Error("The boundary returned an invalid outcome"));
+    }
+}
+function invoke(handler, values) {
+    Promise.resolve().then(() => handler(...values)).catch(error => queueMicrotask(() => { throw error; }));
+}
+function once(cleanup) {
+    let active = true;
+    return () => {
+        if (!active)
+            return;
+        active = false;
+        cleanup();
+    };
+}
+const wire = new Wire();
+captureClientOutput(wire);
+export default wire;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@phreshos/client",
+  "version": "0.1.0",
+  "description": "The SDK used by a Program's client endpoint.",
+  "type": "module",
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/main.d.ts",
+      "default": "./dist/main.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "check": "tsc --noEmit",
+    "build": "tsc --noEmit false --outDir dist --rootDir source",
+    "prepack": "node --run build"
+  },
+  "peerDependencies": {
+    "@phreshos/core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@phreshos/core": "0.1.0",
+    "typescript": "^6.0.3"
+  }
+}