castle-web-sdk 0.4.1 → 0.4.3

package/dist/runtime.d.ts

@@ -0,0 +1,12 @@
+export declare const CARD_RATIO: number;
+interface LocalResponse {
+    type: string;
+    requestId?: string;
+    ok?: boolean;
+    error?: string;
+    [key: string]: unknown;
+}
+export declare function setup(): void;
+export declare function writeFile(path: string, contents: string): Promise<LocalResponse>;
+export declare function initCard(): HTMLDivElement;
+export {};

package/dist/runtime.js

@@ -0,0 +1,288 @@
+import { getCastleEmbed, isEdit } from "./context";
+export const CARD_RATIO = 5 / 7;
+let ws = null;
+let logBuffer = [];
+let nextRequestId = 1;
+const pendingRequests = new Map();
+const origLog = console.log;
+const origWarn = console.warn;
+const origError = console.error;
+// Indirected dynamic import so deck bundlers don't statically rewrite it.
+// eslint-disable-next-line @typescript-eslint/no-implied-eval
+const dynamicImport = new Function("u", "return import(u)");
+export function setup() {
+    interceptConsole();
+    connectLocal();
+    initPlayCard();
+}
+export function writeFile(path, contents) {
+    return sendLocalRequest({
+        type: "write_file",
+        path,
+        contents,
+    });
+}
+export function initCard() {
+    const style = document.createElement("style");
+    style.textContent = `
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    html, body { width: 100%; height: 100%; background: #000; overflow: hidden; }
+    body { display: flex; align-items: center; justify-content: center; }
+    #castle-card {
+      position: relative;
+      border-radius: 4% / calc(4% * (5 / 7));
+      overflow: hidden;
+      background: #121213;
+    }
+  `;
+    document.head.appendChild(style);
+    const card = document.createElement("div");
+    card.id = "castle-card";
+    document.body.appendChild(card);
+    function resize() {
+        if (getCastleEmbed()?.feed === true) {
+            card.style.width = "100vw";
+            card.style.height = "100vh";
+            return;
+        }
+        const { w, h } = computeCardSize();
+        card.style.width = w + "px";
+        card.style.height = h + "px";
+    }
+    resize();
+    window.addEventListener("resize", resize);
+    return card;
+}
+// Constrains whatever the deck renders into #root to a centered 5:7 card.
+// The mobile feed host card-sizes its WebView itself, and the editor needs the
+// full viewport, so the card shell applies only to standalone play.
+function initPlayCard() {
+    if (isEdit())
+        return;
+    if (getCastleEmbed()?.feed === true)
+        return;
+    const style = document.createElement("style");
+    style.textContent = `
+    html, body { background: #000; }
+    #root > * {
+      position: fixed !important;
+      inset: auto !important;
+      left: 50% !important;
+      top: 50% !important;
+      transform: translate(-50%, -50%) !important;
+      width: var(--castle-card-w, 100vw) !important;
+      height: var(--castle-card-h, 100vh) !important;
+      border-radius: 4% / calc(4% * (5 / 7)) !important;
+      overflow: hidden !important;
+    }
+  `;
+    document.head.appendChild(style);
+    function resize() {
+        const { w, h } = computeCardSize();
+        document.documentElement.style.setProperty("--castle-card-w", w + "px");
+        document.documentElement.style.setProperty("--castle-card-h", h + "px");
+    }
+    resize();
+    window.addEventListener("resize", resize);
+}
+function computeCardSize() {
+    const maxW = 450;
+    const maxH = 630;
+    const pad = 20;
+    const aw = window.innerWidth - pad * 2;
+    const ah = window.innerHeight - pad * 2;
+    let w;
+    let h;
+    if (aw / ah < CARD_RATIO) {
+        w = Math.min(aw, maxW);
+        h = w / CARD_RATIO;
+    }
+    else {
+        h = Math.min(ah, maxH);
+        w = h * CARD_RATIO;
+    }
+    return { w, h };
+}
+function sendMsg(msg) {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(msg));
+    }
+    else {
+        logBuffer.push(msg);
+    }
+}
+function sendLocalRequest(msg) {
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+        return Promise.reject(new Error("Castle local CLI is not connected."));
+    }
+    const requestId = `req_${nextRequestId++}`;
+    const request = { ...msg, requestId };
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            pendingRequests.delete(requestId);
+            reject(new Error(`Timed out waiting for ${msg.type}.`));
+        }, 10000);
+        pendingRequests.set(requestId, { resolve, reject, timeout });
+        ws.send(JSON.stringify(request));
+    });
+}
+function resolveLocalRequest(msg) {
+    if (!msg.requestId)
+        return false;
+    const pending = pendingRequests.get(msg.requestId);
+    if (!pending)
+        return false;
+    clearTimeout(pending.timeout);
+    pendingRequests.delete(msg.requestId);
+    if (msg.ok) {
+        pending.resolve(msg);
+    }
+    else {
+        pending.reject(new Error(msg.error || "Castle local request failed."));
+    }
+    return true;
+}
+function interceptConsole() {
+    console.log = (...args) => {
+        origLog(...args);
+        sendMsg({ type: "log", level: "log", msg: formatConsoleArgs(args) });
+    };
+    console.warn = (...args) => {
+        origWarn(...args);
+        sendMsg({ type: "log", level: "warn", msg: formatConsoleArgs(args) });
+    };
+    console.error = (...args) => {
+        origError(...args);
+        sendMsg({ type: "log", level: "error", msg: formatConsoleArgs(args) });
+    };
+}
+function formatConsoleArgs(args) {
+    return args
+        .map((arg) => {
+        if (typeof arg === "string")
+            return arg;
+        if (arg instanceof Error)
+            return arg.stack || arg.message;
+        try {
+            const json = JSON.stringify(arg);
+            return json ?? String(arg);
+        }
+        catch {
+            return String(arg);
+        }
+    })
+        .join(" ");
+}
+async function captureWithHtml2Canvas(target) {
+    try {
+        const mod = (await dynamicImport("https://esm.sh/html2canvas"));
+        const c = await mod.default(target, {
+            backgroundColor: null,
+            scale: devicePixelRatio,
+            useCORS: true,
+        });
+        return c.toDataURL("image/png");
+    }
+    catch {
+        return null;
+    }
+}
+async function captureScreenshot() {
+    const card = document.getElementById("castle-card");
+    const canvas = document.querySelector("canvas");
+    if (document.body?.dataset.castleScreenshotTarget === "viewport") {
+        const viewportCapture = await captureWithHtml2Canvas(document.body);
+        if (viewportCapture)
+            return viewportCapture;
+    }
+    if (card && canvas) {
+        const cardRect = card.getBoundingClientRect();
+        const c = document.createElement("canvas");
+        c.width = cardRect.width * devicePixelRatio;
+        c.height = cardRect.height * devicePixelRatio;
+        const ctx = c.getContext("2d");
+        const canvasRect = canvas.getBoundingClientRect();
+        const dx = (canvasRect.left - cardRect.left) * devicePixelRatio;
+        const dy = (canvasRect.top - cardRect.top) * devicePixelRatio;
+        ctx.drawImage(canvas, dx, dy, canvasRect.width * devicePixelRatio, canvasRect.height * devicePixelRatio);
+        return c.toDataURL("image/png");
+    }
+    if (canvas)
+        return canvas.toDataURL("image/png");
+    return captureWithHtml2Canvas(card || document.body);
+}
+function connectLocal() {
+    fetch("/__castle/ws-port")
+        .then((r) => r.json())
+        .then(({ port, path }) => {
+        if (!port && !path)
+            return;
+        const socket = new WebSocket(path ? localWsUrl(path) : `ws://localhost:${port}`);
+        socket.onopen = () => {
+            ws = socket;
+            for (const msg of logBuffer)
+                ws.send(JSON.stringify(msg));
+            logBuffer = [];
+        };
+        socket.onmessage = (evt) => {
+            try {
+                const msg = JSON.parse(evt.data);
+                handleLocalMessage(msg);
+            }
+            catch {
+                // ignore malformed messages
+            }
+        };
+        socket.onclose = () => {
+            ws = null;
+            for (const [requestId, pending] of pendingRequests) {
+                clearTimeout(pending.timeout);
+                pending.reject(new Error("Castle local CLI disconnected."));
+                pendingRequests.delete(requestId);
+            }
+            setTimeout(connectLocal, 2000);
+        };
+        socket.onerror = () => socket.close();
+    })
+        .catch(() => { });
+}
+function handleLocalMessage(msg) {
+    if (msg.type === "screenshot_request") {
+        void captureScreenshot()
+            .then((data) => {
+            if (data) {
+                sendMsg({
+                    type: "screenshot_response",
+                    requestId: msg.requestId,
+                    data,
+                });
+                return;
+            }
+            sendMsg({
+                type: "screenshot_response",
+                requestId: msg.requestId,
+                ok: false,
+                error: "Could not capture screenshot.",
+            });
+        })
+            .catch((error) => {
+            sendMsg({
+                type: "screenshot_response",
+                requestId: msg.requestId,
+                ok: false,
+                error: error instanceof Error ? error.message : "Could not capture screenshot.",
+            });
+        });
+    }
+    else if (msg.type === "restart") {
+        location.reload();
+    }
+    else if (msg.type === "write_file_response") {
+        resolveLocalRequest(msg);
+    }
+}
+function localWsUrl(path) {
+    const url = new URL(path, location.href);
+    url.protocol = location.protocol === "https:" ? "wss:" : "ws:";
+    return url.href;
+}

package/dist/storage.d.ts

@@ -0,0 +1,17 @@
+import type { Json } from "./types";
+type SharedScope = "deck" | "user";
+export interface StorageApi {
+    get<T extends Json = Json>(key: string): Promise<T | null>;
+    set(key: string, value: Json): void;
+    remove(key: string): void;
+}
+export interface SharedStorageApi {
+    get<T extends Json = Json>(scope: "deck", key: string): Promise<T | null>;
+    get<T extends Json = Json>(scope: "user", key: string): Promise<T | null>;
+    get<T extends Json = Json>(scope: "user", userId: string, key: string): Promise<T | null>;
+    set(scope: SharedScope, key: string, value: Json): void;
+    remove(scope: SharedScope, key: string): void;
+}
+export declare const Storage: StorageApi;
+export declare const SharedStorage: SharedStorageApi;
+export {};