@peekling/runtime 0.1.0

package/dist/input.js

@@ -0,0 +1,215 @@
+import { runtimeMessage } from "./runtime-diagnostics.js";
+export class InputCollector {
+    pointer;
+    reactions = [];
+    lastActivityAt;
+    #nextReactionId = 1;
+    #listeners = [];
+    #events = new Map();
+    #document;
+    #window;
+    #now;
+    #wake;
+    #diagnostic;
+    #coalesce;
+    #suspended = false;
+    constructor(document, window, options) {
+        this.#document = document;
+        this.#window = window;
+        this.#now = options.now;
+        this.#wake = options.wake;
+        this.#diagnostic = options.diagnostic ?? (() => { });
+        this.lastActivityAt = options.now();
+        this.#listen(window, "resize", () => this.#wake());
+        for (const event of options.events)
+            this.#retainEvent(event);
+        this.#coalesce = options.coalesce ?? new Map();
+    }
+    get reaction() {
+        return this.reactions[0];
+    }
+    captureReaction(name, payload, source = "application") {
+        const at = this.#now();
+        const last = this.reactions.at(-1);
+        const policy = this.#coalesce.get(`${source}:${name}`);
+        const coalesced = Boolean(last?.name === name &&
+            last.source === source &&
+            (policy === true ||
+                (policy !== undefined && newerRevision(last.payload, payload, policy))));
+        if (!coalesced && this.reactions.length >= 32) {
+            this.#diagnostic(runtimeMessage("event.queue-full", "Event queue overflow rejected the newest event"));
+            return { accepted: false, reason: "queue-full" };
+        }
+        // A coalesced queue tail keeps its original ID so acceptance and
+        // consumption continue to refer to the same logical event.
+        const reaction = {
+            id: coalesced ? last.id : this.#nextReactionId++,
+            source,
+            name,
+            at,
+            ...(payload === undefined ? {} : { payload }),
+        };
+        if (coalesced)
+            this.reactions[this.reactions.length - 1] = reaction;
+        else
+            this.reactions.push(reaction);
+        this.lastActivityAt = at;
+        this.#wake();
+        return { accepted: true, id: reaction.id, coalesced };
+    }
+    consumeReaction(id) {
+        if (this.reactions[0]?.id === id)
+            this.reactions.shift();
+    }
+    retainEvent(event) {
+        this.#retainEvent(event);
+        let retained = true;
+        return () => {
+            if (!retained)
+                return;
+            retained = false;
+            this.#releaseEvent(event);
+        };
+    }
+    setSuspended(value) {
+        if (value === this.#suspended)
+            return;
+        this.#suspended = value;
+        for (const binding of this.#listeners) {
+            if (value && binding[3] && !binding[4]) {
+                binding[0].removeEventListener(binding[1], binding[2]);
+                binding[3] = false;
+            }
+            else if (!value && !binding[3]) {
+                binding[0].addEventListener(binding[1], binding[2], { passive: true });
+                binding[3] = true;
+            }
+        }
+        if (value)
+            this.pointer = undefined;
+    }
+    destroy() {
+        for (const binding of this.#listeners.splice(0)) {
+            if (binding[3])
+                binding[0].removeEventListener(binding[1], binding[2]);
+        }
+        this.pointer = undefined;
+        this.reactions.length = 0;
+        this.#events.clear();
+    }
+    #retainEvent(event) {
+        const retained = this.#events.get(event);
+        if (retained) {
+            retained[0] += 1;
+            return;
+        }
+        const bindings = [];
+        this.#events.set(event, [1, bindings]);
+        const listen = (target, type, listener, persistent = false) => bindings.push(this.#listen(target, type, listener, persistent));
+        if (event === "pointer.move") {
+            listen(this.#document, "pointerdown", (input) => {
+                const pointer = input;
+                if (pointer.pointerType === "touch" || pointer.pointerType === "pen") {
+                    this.#capturePointer(pointer);
+                }
+            });
+            listen(this.#document, "pointermove", (input) => this.#capturePointer(input));
+            const clearTouch = (input) => {
+                const type = input.pointerType;
+                if (type === "touch" || type === "pen")
+                    this.#clearPointer();
+            };
+            listen(this.#document, "pointerup", clearTouch);
+            listen(this.#document, "pointercancel", clearTouch);
+            listen(this.#document, "pointerout", (input) => {
+                if (input.relatedTarget === null)
+                    this.#clearPointer();
+            });
+            listen(this.#window, "blur", () => this.#clearPointer());
+        }
+        else if (event === "pointer.click") {
+            listen(this.#document, "click", (input) => this.#captureObserved("pointer.click", input));
+        }
+        else if (event === "document.visibility") {
+            listen(this.#document, "visibilitychange", () => this.captureReaction("document.visibility", { visible: !this.#document.hidden }, "browser"), true);
+        }
+        else if (event === "window.scroll") {
+            listen(this.#window, "scroll", (input) => this.#captureObserved("window.scroll", input));
+        }
+        else if (event === "window.focus") {
+            listen(this.#window, "focus", () => this.captureReaction("window.focus", { focused: true }, "browser"));
+            listen(this.#window, "blur", () => this.captureReaction("window.focus", { focused: false }, "browser"));
+        }
+    }
+    #releaseEvent(event) {
+        const retained = this.#events.get(event);
+        if (!retained)
+            return;
+        if (retained[0] > 1) {
+            retained[0] -= 1;
+            return;
+        }
+        this.#events.delete(event);
+        for (const binding of retained[1]) {
+            if (binding[3])
+                binding[0].removeEventListener(binding[1], binding[2]);
+            const index = this.#listeners.indexOf(binding);
+            if (index >= 0)
+                this.#listeners.splice(index, 1);
+        }
+    }
+    #clearPointer() {
+        if (this.#suspended)
+            return;
+        if (!this.pointer)
+            return;
+        this.pointer = undefined;
+        this.lastActivityAt = this.#now();
+        this.#wake();
+    }
+    #capturePointer(pointer) {
+        if (this.#suspended)
+            return;
+        this.pointer = { x: pointer.clientX, y: pointer.clientY };
+        this.lastActivityAt = this.#now();
+        this.#wake();
+    }
+    #captureObserved(name, event) {
+        if (this.#suspended)
+            return;
+        if (event
+            .composedPath()
+            .some((target) => "hasAttribute" in target &&
+            typeof target.hasAttribute === "function" &&
+            target.hasAttribute("data-peekling-controls")))
+            return;
+        const pointer = event;
+        const payload = Number.isFinite(pointer.clientX) && Number.isFinite(pointer.clientY)
+            ? { x: pointer.clientX, y: pointer.clientY }
+            : undefined;
+        this.captureReaction(name, payload, "browser");
+    }
+    #listen(target, type, listener, persistent = false) {
+        const options = { passive: true };
+        target.addEventListener(type, listener, options);
+        const binding = [target, type, listener, true, persistent];
+        this.#listeners.push(binding);
+        return binding;
+    }
+}
+function newerRevision(previous, next, policy) {
+    if (!previous ||
+        !next ||
+        typeof previous !== "object" ||
+        typeof next !== "object" ||
+        Array.isArray(previous) ||
+        Array.isArray(next))
+        return false;
+    const prior = previous;
+    const incoming = next;
+    return (incoming[policy.sessionField] === prior[policy.sessionField] &&
+        Number.isSafeInteger(incoming[policy.revisionField]) &&
+        Number.isSafeInteger(prior[policy.revisionField]) &&
+        incoming[policy.revisionField] >
+            prior[policy.revisionField]);
+}

package/dist/json.d.ts

@@ -0,0 +1,3 @@
+/** Parse bounded JSON while rejecting ambiguous duplicate object keys. */
+export declare function parseDataText(text: string, label: string, maxBytes?: number): unknown;
+//# sourceMappingURL=json.d.ts.map

package/dist/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAKA,0EAA0E;AAC1E,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,QAAQ,SAAY,GACnB,OAAO,CAmCT"}

package/dist/json.js

@@ -0,0 +1,109 @@
+import { packIssue, PackValidationError } from "./errors.js";
+const MAX_JSON_NESTING = 64;
+const JSON_NESTING_ERROR = 0;
+/** Parse bounded JSON while rejecting ambiguous duplicate object keys. */
+export function parseDataText(text, label, maxBytes = 64 * 1024) {
+    if (new TextEncoder().encode(text).byteLength > maxBytes) {
+        throw new PackValidationError([
+            packIssue(`${label}.size`, `${label} exceeds ${maxBytes} bytes`),
+        ]);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new PackValidationError([
+            packIssue(`${label}.json`, `${label} is not valid JSON`),
+        ]);
+    }
+    let duplicate;
+    try {
+        duplicate = firstDuplicateKey(text);
+    }
+    catch (cause) {
+        if (cause !== JSON_NESTING_ERROR)
+            throw cause;
+        throw new PackValidationError([
+            packIssue(`${label}.depth`, `${label} nesting exceeds ${MAX_JSON_NESTING} levels`),
+        ]);
+    }
+    if (duplicate !== undefined) {
+        throw new PackValidationError([
+            packIssue(`${label}.duplicate-key`, `${label} contains duplicate object key ${JSON.stringify(duplicate)}`),
+        ]);
+    }
+    return parsed;
+}
+function firstDuplicateKey(text) {
+    let cursor = 0;
+    let duplicate;
+    const space = () => {
+        while (/\s/.test(text[cursor] ?? ""))
+            cursor++;
+    };
+    const string = () => {
+        const start = cursor++;
+        while (cursor < text.length) {
+            if (text[cursor] === "\\")
+                cursor += 2;
+            else if (text[cursor++] === '"')
+                break;
+        }
+        return JSON.parse(text.slice(start, cursor));
+    };
+    const value = (depth = 0) => {
+        space();
+        if (text[cursor] === "{") {
+            if (depth >= MAX_JSON_NESTING)
+                throw JSON_NESTING_ERROR;
+            cursor++;
+            const keys = new Set();
+            space();
+            while (text[cursor] !== "}") {
+                const key = string();
+                if (keys.has(key) && duplicate === undefined)
+                    duplicate = key;
+                keys.add(key);
+                space();
+                cursor++;
+                value(depth + 1);
+                space();
+                if (text[cursor] === ",") {
+                    cursor++;
+                    space();
+                }
+                else
+                    break;
+            }
+            cursor++;
+            return;
+        }
+        if (text[cursor] === "[") {
+            if (depth >= MAX_JSON_NESTING)
+                throw JSON_NESTING_ERROR;
+            cursor++;
+            space();
+            while (text[cursor] !== "]") {
+                value(depth + 1);
+                space();
+                if (text[cursor] === ",") {
+                    cursor++;
+                    space();
+                }
+                else
+                    break;
+            }
+            cursor++;
+            return;
+        }
+        if (text[cursor] === '"') {
+            string();
+            return;
+        }
+        while (cursor < text.length && !/[\s,}\]]/.test(text[cursor]))
+            cursor++;
+    };
+    value();
+    return duplicate;
+}

package/dist/loader.d.ts

@@ -0,0 +1,33 @@
+import type { PackLoadFailureCategory } from "./errors.js";
+import type { NativeDensity, NormalizedPack } from "./types.js";
+export interface LoadPackOptions {
+    character?: string;
+    baseUrl: string;
+    pack?: unknown;
+    packUrl?: string;
+    atlasUrl?: string;
+    renderScale?: number;
+    devicePixelRatio?: number;
+    densityOverride?: NativeDensity;
+    maxDensity?: NativeDensity;
+    fetch: typeof globalThis.fetch;
+    image: () => HTMLImageElement;
+    signal: AbortSignal;
+    /** Package-internal override used by deterministic loader tests. */
+    resourceTimeoutMs?: number;
+    createObjectURL: (blob: Blob) => string;
+    revokeObjectURL: (url: string) => void;
+    diagnostic?: (message: string, category?: PackLoadFailureCategory) => void;
+}
+export type { PackLoadFailureCategory } from "./errors.js";
+export interface LoadedPack {
+    readonly content: NormalizedPack;
+    readonly atlasObjectUrl: string;
+    readonly loadedDensity: number;
+    upgrade(requiredDensity: number): Promise<boolean>;
+    release(): void;
+}
+export declare function resolveManifestUrl(input: string, base: string): string;
+export declare function requiredAtlasDensity(devicePixelRatio: number, renderScale: number, maxDensity?: NativeDensity): number;
+export declare function loadNativePack(options: LoadPackOptions): Promise<LoadedPack>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAU3D,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAUhE,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAC/B,KAAK,EAAE,MAAM,gBAAgB,CAAC;IAC9B,MAAM,EAAE,WAAW,CAAC;IACpB,oEAAoE;IACpE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC;IACxC,eAAe,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,uBAAuB,KAAK,IAAI,CAAC;CAC5E;AAED,YAAY,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAE3D,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,OAAO,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnD,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAQtE;AAgUD,wBAAgB,oBAAoB,CAClC,gBAAgB,EAAE,MAAM,EACxB,WAAW,EAAE,MAAM,EACnB,UAAU,GAAE,aAAiB,GAC5B,MAAM,CAMR;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,UAAU,CAAC,CAuUrB"}