@phreshos/client 0.1.52 → 0.1.54

package/dist/desktop/viewport.d.ts

@@ -1,9 +1,15 @@
-import type { DesktopViewportEvents, DesktopViewportSource } from "@phreshos/core";
+import type { DesktopOffset, DesktopViewportEvents, WritableDesktopViewportSource } from "@phreshos/core";
 import Events from "../events.js";
-/** Read-only access to the Desktop viewport containing this Client Endpoint. */
-export default class ClientViewport extends Events<DesktopViewportEvents, never> implements DesktopViewportSource {
+/** The Desktop viewport containing this Client Endpoint: its size, where it looks on the plane, and moving that view. */
+export default class ClientViewport extends Events<DesktopViewportEvents, never> implements WritableDesktopViewportSource {
     constructor();
-    snapshot(): Promise<Readonly<{
-        size: import("@phreshos/core").DesktopSize;
+    size(): Promise<Readonly<{
+        width: number;
+        height: number;
     }>>;
+    offset(): Promise<Readonly<{
+        x: number;
+        y: number;
+    }>>;
+    move(offset: DesktopOffset): Promise<void>;
 }

package/dist/desktop/viewport.js

@@ -1,33 +1,57 @@
 import Events from "../events.js";
 import wire from "../wire.js";
-/** Read-only access to the Desktop viewport containing this Client Endpoint. */
+/** The Desktop viewport containing this Client Endpoint: its size, where it looks on the plane, and moving that view. */
 export default class ClientViewport extends Events {
     constructor() {
         super((event, listener, impossible) => wire.on("host-desktop-viewport", event, value => {
-            const snapshot = createSnapshot(value);
-            if (snapshot)
-                listener(snapshot);
+            const parsed = parse(event, value);
+            if (parsed)
+                listener(parsed);
         }, null, impossible), observer => wire.onAll("host-desktop-viewport", (event, value) => {
-            const snapshot = createSnapshot(value);
-            if (typeof event === "string" && snapshot)
-                observer(event, snapshot);
+            const parsed = typeof event === "string" ? parse(event, value) : null;
+            if (typeof event === "string" && parsed)
+                observer(event, parsed);
         }));
     }
-    async snapshot() {
-        const answer = await wire.request(["desktopViewport"]);
-        const snapshot = createSnapshot(answer[0]);
-        if (!snapshot)
-            throw new Error("The System returned an invalid Desktop viewport");
-        return snapshot;
+    async size() {
+        const size = createSize((await state()).size);
+        if (!size)
+            throw new Error("The System returned an invalid Desktop size");
+        return size;
     }
+    async offset() {
+        const offset = createOffset((await state()).offset);
+        if (!offset)
+            throw new Error("The System returned an invalid Desktop offset");
+        return offset;
+    }
+    async move(offset) {
+        const target = createOffset(offset);
+        if (!target)
+            throw new Error("A Desktop offset needs finite x and y");
+        await wire.request(["moveDesktopViewport", target]);
+    }
+}
+async function state() {
+    const answer = await wire.request(["desktopViewport"]);
+    return record(answer[0]) ? answer[0] : {};
 }
-function createSnapshot(value) {
-    if (!record(value) || !record(value.size))
+function parse(event, value) {
+    if (event === "resize")
+        return createSize(value);
+    if (event === "move")
+        return createOffset(value);
+    return null;
+}
+function createSize(value) {
+    if (!record(value) || !finite(value.width) || !finite(value.height))
         return null;
-    const { width, height } = value.size;
-    if (!finite(width) || !finite(height))
+    return Object.freeze({ width: value.width, height: value.height });
+}
+function createOffset(value) {
+    if (!record(value) || !finite(value.x) || !finite(value.y))
         return null;
-    return Object.freeze({ size: Object.freeze({ width, height }) });
+    return Object.freeze({ x: value.x, y: value.y });
 }
 function record(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/storage.js

@@ -200,16 +200,67 @@ function parseEntry(value) {
     return { kind: entry.kind, path: entry.path };
 }
 export function store(program) {
+    const snapshots = new Map();
+    const local = new Set();
+    const notify = (key, snapshot) => { for (const listener of local)
+        listener(key, snapshot); };
     async function ask(operation, ...values) {
         const answer = await wire.request(["store", program, operation, ...values]);
         return answer[0];
     }
     return {
         get: (key) => ask("get", key),
-        set: (key, value, ttl) => ask("set", key, value, ttl),
-        delete: (key) => ask("delete", key),
+        async set(key, value, ttl) {
+            const result = await ask("set", key, value, ttl);
+            snapshots.delete(key);
+            return result;
+        },
+        async getOrSet(key, initial) {
+            // The response carries the authoritative revision so an older initial event cannot win hydration.
+            const snapshot = await ask("getOrSet", key, initial);
+            notify(key, snapshot);
+            return snapshot.value;
+        },
+        async update(key, updater) {
+            let snapshot = snapshots.get(key) ?? await ask("snapshot", key);
+            for (;;) {
+                const next = updater(snapshot.value);
+                const result = await ask("compareAndSet", key, next, snapshot);
+                snapshots.set(key, result.snapshot);
+                notify(key, result.snapshot);
+                if (result.changed)
+                    return result.snapshot.value;
+                snapshot = result.snapshot;
+            }
+        },
+        async delete(key) {
+            const result = await ask("delete", key);
+            for (const name of Array.isArray(key) ? key : [key])
+                snapshots.delete(name);
+            return result;
+        },
         has: (key) => ask("has", key),
-        clear: () => ask("clear")
+        async clear() { await ask("clear"); snapshots.clear(); },
+        subscribe(key, subscriber) {
+            let active = true;
+            let latest;
+            const deliver = (snapshot) => {
+                if (!active || (latest?.run === snapshot.run && latest.revision >= snapshot.revision))
+                    return;
+                latest = snapshot;
+                snapshots.set(key, snapshot);
+                subscriber(snapshot.value);
+            };
+            const stop = wire.on("program-host", "storeChange", (reference, changedKey, snapshot) => {
+                if (reference === program.reference && changedKey === key)
+                    deliver(snapshot);
+            }, program.reference);
+            const localListener = (changedKey, snapshot) => { if (changedKey === key)
+                deliver(snapshot); };
+            local.add(localListener);
+            void ask("snapshot", key).then(deliver).catch(() => undefined);
+            return () => { active = false; local.delete(localListener); stop(); };
+        }
     };
 }
 export function sql(kind, program) {

package/dist/system.js

@@ -1,4 +1,4 @@
-import { parseShellEvent, parseAuthenticationRequirements, parseAuthenticationState, parsePermissions, parseSessionEndSnapshot, execute as executeRequest } from "@phreshos/core";
+import { parseShellEvent, parseAuthenticationRequirements, parseAuthenticationState, parsePermissions, parseSessionEndSnapshot, parseSystemProgramListOptions, parseSystemServiceListOptions, execute as executeRequest } from "@phreshos/core";
 import ClientAppearance from "./appearance.js";
 import wire from "./wire.js";
 import { prepareService } from "./service.js";
@@ -36,12 +36,8 @@ class SystemServiceHandle extends Events {
                 observer(event, prepareService(values[1]));
         }));
     }
-    async list() {
-        const [addresses] = await wire.request(["host-service-list"]);
-        return addresses.map(address => prepareService(address));
-    }
-    async search(name) {
-        const [addresses] = await wire.request(["host-service-search", name]);
+    async list(options = {}) {
+        const [addresses] = await wire.request(["host-service-list", parseSystemServiceListOptions(options)]);
         return addresses.map(address => prepareService(address));
     }
     prepare(address) { return prepareService(address); }
@@ -53,8 +49,8 @@ class SystemProgramHandle extends Events {
                 observer(event, systemProgramEvent(event, values));
         }));
     }
-    async list(onlyInstalled = false) {
-        const answer = await wire.request(["host-program-list", onlyInstalled]);
+    async list(options = {}) {
+        const answer = await wire.request(["host-program-list", parseSystemProgramListOptions(options)]);
         return answer[0].map(program);
     }
     async find(identity) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phreshos/client",
-  "version": "0.1.52",
+  "version": "0.1.54",
   "description": "The SDK used by a Program's client endpoint.",
   "type": "module",
   "main": "dist/main.js",
@@ -46,13 +46,13 @@
     "test": "vitest run --project default"
   },
   "peerDependencies": {
-    "@phreshos/core": "^0.1.62"
+    "@phreshos/core": "^0.1.64"
   },
   "dependencies": {
     "@the-link/messagepack": "^0.1.0"
   },
   "devDependencies": {
-        "@phreshos/core": "^0.1.62",
+    "@phreshos/core": "^0.1.64",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"
   }