@hoardodile/sdk-web 0.0.0

package/dist/index.js

@@ -0,0 +1,683 @@
+import { imageVariantQuery } from '@hoardodile/sdk-types/image-variant';
+
+// src/protocol.ts
+var PROTOCOL_VERSION = 1;
+var pluginThemePalettes = [
+  "mono",
+  "sage",
+  "parchment",
+  "azure",
+  "hoardodile"
+];
+var hostPushKeys = {
+  context: "context",
+  visibility: "visibility",
+  themeChanged: "themeChanged",
+  fontsChanged: "fontsChanged",
+  languageChanged: "languageChanged",
+  prefsChanged: "prefsChanged",
+  cacheChanged: "cacheChanged",
+  anchorJump: "anchorJump",
+  resInvalidate: "res:invalidate",
+  resourcesInvalidate: "resources:invalidate",
+  messagesInvalidate: "messages:invalidate",
+  danmakuInvalidate: "danmaku:invalidate"
+};
+var pluginMethods = {
+  // Files
+  readFile: "readFile",
+  listFiles: "listFiles",
+  // Messages
+  listMessages: "listMessages",
+  createMessage: "createMessage",
+  // Danmaku
+  listDanmaku: "listDanmaku",
+  createDanmaku: "createDanmaku",
+  // Preferences / cache
+  setPref: "setPref",
+  setCache: "setCache",
+  // Cache invalidation
+  invalidate: "invalidate",
+  // Plugin asset vault
+  download: "download",
+  deleteAsset: "deleteAsset",
+  // Logging — must match the PluginRequests keys exactly,
+  // otherwise plugin log calls are silently swallowed.
+  logInfo: "logInfo",
+  logWarn: "logWarn",
+  logError: "logError"
+};
+var invalidatePushKeys = {
+  resource: hostPushKeys.resInvalidate,
+  resources: hostPushKeys.resourcesInvalidate,
+  messages: hostPushKeys.messagesInvalidate,
+  danmaku: hostPushKeys.danmakuInvalidate
+};
+var pluginRequestTimeouts = {
+  readFile: 12e4,
+  download: 3e5
+};
+
+// src/bridge.ts
+var REQUEST_TIMEOUT_MS = 1e4;
+var nextId = 1;
+var hostBridge;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isValidHostMessage(msg) {
+  return isRecord(msg) && "type" in msg;
+}
+function ensureHostBridge() {
+  if (hostBridge !== void 0) return hostBridge;
+  const pending = /* @__PURE__ */ new Map();
+  const subscribers = /* @__PURE__ */ new Map();
+  window.addEventListener(
+    "message",
+    function handleMessage(event) {
+      const selfEmbedded = window.parent === window;
+      if (event.source !== window.parent && !(selfEmbedded && event.source === null)) {
+        return;
+      }
+      const msg = event.data;
+      if (!isValidHostMessage(msg)) return;
+      if (msg.type === "response") {
+        const entry = pending.get(msg.id);
+        if (entry === void 0) return;
+        pending.delete(msg.id);
+        clearTimeout(entry.timeoutId);
+        if (msg.ok) {
+          entry.resolve(msg.data);
+        } else {
+          const err = new Error(msg.error ?? "Unknown error");
+          const code = msg.errorCode ?? msg.errorName;
+          if (code !== void 0 && code.length > 0) {
+            err.name = code;
+          }
+          entry.reject(err);
+        }
+      } else if (msg.type === "push") {
+        const handlers = subscribers.get(msg.key);
+        if (handlers !== void 0) {
+          for (const handler of handlers) {
+            handler(msg.data);
+          }
+        }
+      }
+    }
+  );
+  function request(resId, method, ...args) {
+    const id = nextId++;
+    const input = args[0];
+    const timeoutMs = pluginRequestTimeouts[method] ?? REQUEST_TIMEOUT_MS;
+    const params = input;
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`Request timed out: ${String(method)}`));
+      }, timeoutMs);
+      pending.set(id, {
+        resolve,
+        reject,
+        timeoutId
+      });
+      const message = {
+        type: "request",
+        id,
+        method,
+        params,
+        proto: PROTOCOL_VERSION,
+        resId
+      };
+      window.parent.postMessage(message, "*");
+    });
+  }
+  function subscribe(key, handler) {
+    const keyString = key;
+    let handlers = subscribers.get(keyString);
+    if (handlers === void 0) {
+      handlers = /* @__PURE__ */ new Set();
+      subscribers.set(keyString, handlers);
+      const message = {
+        type: "subscribe",
+        key: keyString,
+        proto: PROTOCOL_VERSION
+      };
+      window.parent.postMessage(message, "*");
+    }
+    const wrapped = (data) => handler(data);
+    handlers.add(wrapped);
+    return function unsubscribe() {
+      handlers.delete(wrapped);
+      if (handlers.size === 0) {
+        subscribers.delete(keyString);
+      }
+    };
+  }
+  function makeHost(resId) {
+    return {
+      request(method, ...args) {
+        return request(resId, method, ...args);
+      },
+      subscribe,
+      withScope: makeHost
+    };
+  }
+  hostBridge = makeHost(void 0);
+  return hostBridge;
+}
+
+// src/codecs.ts
+function jsonCodec() {
+  return {
+    encode(value) {
+      return JSON.stringify(value);
+    },
+    decode(raw) {
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+function numberCodec(fallback) {
+  return {
+    encode(value) {
+      return String(value);
+    },
+    decode(raw) {
+      const n = Number(raw);
+      return Number.isFinite(n) ? n : fallback;
+    }
+  };
+}
+function booleanCodec() {
+  return {
+    encode(value) {
+      return value ? "1" : "0";
+    },
+    decode(raw) {
+      if (raw === "1" || raw === "true") return true;
+      if (raw === "0" || raw === "false") return false;
+      return void 0;
+    }
+  };
+}
+function mergeDeep(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue !== void 0 && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== void 0 && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+      result[key] = mergeDeep(
+        targetValue,
+        sourceValue
+      );
+    } else if (sourceValue !== void 0) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function createWebPluginAPI(overrides) {
+  const base = {
+    logInfo: () => {
+    },
+    logWarn: () => {
+    },
+    logError: () => {
+    },
+    resource: {
+      id: "r-test",
+      name: "test",
+      sourceMeta: void 0,
+      searchMeta: void 0,
+      fileStats: void 0,
+      contentPluginId: "p-test"
+    },
+    listFiles: async () => [],
+    readFile: async () => new ArrayBuffer(0),
+    resolveFileUrl: (filename, variant) => buildMockFileUrl(filename, variant),
+    resolveExtractedUrl: (path) => `/extracted/${path}`,
+    extractProgressUrl: () => "/extract-progress/",
+    resolveBaseUrl: () => "/files/",
+    resolveFrameUrl: (filename, timeMs) => `/frame/${filename}/${timeMs}`,
+    download: async () => {
+      throw new Error("download stub not overridden");
+    },
+    resolveAssetUrl: (path) => `/plugin-assets/p-test/./${path}`,
+    deleteAsset: async () => ({ existed: false }),
+    listMessages: async () => [],
+    createMessage: async () => {
+      throw new Error("createMessage stub not overridden");
+    },
+    listDanmaku: async () => [],
+    createDanmaku: async () => {
+      throw new Error("createDanmaku stub not overridden");
+    },
+    getPref: () => void 0,
+    setPref: () => {
+    },
+    getCache: () => void 0,
+    setCache: () => {
+    },
+    listCache: () => [],
+    invalidate: async () => {
+    },
+    onAnchorJump: () => () => {
+    },
+    useFileList: () => ({
+      data: [],
+      isLoading: false,
+      isError: false,
+      error: null
+    }),
+    useMessageList: () => ({
+      data: [],
+      isLoading: false,
+      isError: false,
+      error: null
+    }),
+    useCreateMessage: () => ({
+      mutate: async () => {
+        throw new Error("useCreateMessage stub not overridden");
+      },
+      isPending: false
+    }),
+    useDanmakuList: () => ({
+      data: [],
+      isLoading: false,
+      isError: false,
+      error: null
+    }),
+    useCreateDanmaku: () => ({
+      mutate: async () => {
+        throw new Error("useCreateDanmaku stub not overridden");
+      },
+      isPending: false
+    }),
+    usePref: (_key, defaultValue, _codec) => [defaultValue, (_next) => {
+    }],
+    useTheme: () => ({
+      resolvedTheme: "light",
+      palette: "mono",
+      iconStyle: "duotone"
+    }),
+    useFont: () => ({ family: "", cssPaths: [] })
+  };
+  return overrides === void 0 ? base : mergeDeep(base, overrides);
+}
+function buildMockFileUrl(filename, variant) {
+  const url = `/files/${filename}`;
+  if (variant === "preview") {
+    return `${url}?size=preview`;
+  }
+  if (variant !== void 0 && variant !== "original") {
+    return `${url}?${imageVariantQuery(variant)}`;
+  }
+  return url;
+}
+
+// src/lifecycle.ts
+var pluginContext;
+function getPluginContext() {
+  return pluginContext;
+}
+function setPluginContext(ctx) {
+  pluginContext = ctx;
+}
+var currentVisibility = true;
+var visibilityListeners = /* @__PURE__ */ new Set();
+function subscribeToVisibility(cb) {
+  visibilityListeners.add(cb);
+  return () => {
+    visibilityListeners.delete(cb);
+  };
+}
+function getVisibilitySnapshot() {
+  return currentVisibility;
+}
+function publishVisibilityChange(visible) {
+  if (currentVisibility === visible) return;
+  currentVisibility = visible;
+  for (const cb of visibilityListeners) {
+    cb(visible);
+  }
+}
+function afterNextPaintedFrame(cb) {
+  requestAnimationFrame(() => {
+    requestAnimationFrame(cb);
+  });
+}
+function mountPlugin(mount) {
+  function applyContext(ctx) {
+    setPluginContext(ctx);
+    publishVisibilityChange(true);
+    mount(ctx);
+    afterNextPaintedFrame(() => {
+      window.parent.postMessage(
+        {
+          type: "contextPainted",
+          resId: ctx.resId,
+          proto: PROTOCOL_VERSION
+        },
+        "*"
+      );
+    });
+  }
+  window.addEventListener("message", (event) => {
+    if (event.source !== window.parent) return;
+    const msg = event.data;
+    if (!isRecord2(msg) || msg.type !== "push") return;
+    if (msg.key === hostPushKeys.context) {
+      applyContext(msg.data);
+    } else if (msg.key === hostPushKeys.visibility) {
+      publishVisibilityChange(msg.data.visible);
+    }
+  });
+  window.addEventListener("context-ready", (e) => {
+    applyContext(e.detail);
+  });
+  window.addEventListener("visibility-changed", (e) => {
+    publishVisibilityChange(
+      e.detail.visible
+    );
+  });
+  const w = window;
+  if (w.__pluginContext !== void 0) {
+    applyContext(w.__pluginContext);
+  }
+  if (w.__pluginVisibility !== void 0) {
+    publishVisibilityChange(
+      w.__pluginVisibility.visible
+    );
+  }
+}
+function applyTheme(resolvedTheme, palette, iconStyle) {
+  const root = document.documentElement;
+  root.classList.remove("light", "dark");
+  root.classList.add(resolvedTheme);
+  for (const cls of [...root.classList]) {
+    if (cls.startsWith("theme-")) root.classList.remove(cls);
+  }
+  if (palette !== "mono") {
+    root.classList.add(`theme-${palette}`);
+  }
+  root.dataset.iconStyle = iconStyle;
+}
+var FONT_STYLE_ID = "plugin-host-font";
+function applyFonts(family, cssPaths) {
+  for (const path of cssPaths) {
+    const selector = `link[rel="stylesheet"][href="${path}"]`;
+    if (document.head.querySelector(selector) !== null) continue;
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = path;
+    document.head.appendChild(link);
+  }
+  const root = document.documentElement;
+  if (family === "") {
+    root.style.removeProperty("--font-app");
+  } else {
+    root.style.setProperty("--font-app", family);
+  }
+  if (document.getElementById(FONT_STYLE_ID) === null) {
+    const style = document.createElement("style");
+    style.id = FONT_STYLE_ID;
+    style.textContent = "html{font-family:var(--font-app,var(--font-sans))}";
+    document.head.appendChild(style);
+  }
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/stores.ts
+var pluginPrefStore = /* @__PURE__ */ new Map();
+var pluginCacheStore = /* @__PURE__ */ new Map();
+function seedPluginStores(ctx) {
+  pluginPrefStore.clear();
+  for (const [k, v] of Object.entries(ctx.initialPrefs)) {
+    pluginPrefStore.set(k, v);
+  }
+  pluginCacheStore.clear();
+  for (const [k, v] of Object.entries(ctx.initialCache)) {
+    pluginCacheStore.set(k, v);
+  }
+}
+function getPluginPrefStore() {
+  return pluginPrefStore;
+}
+function setPluginPref(key, value) {
+  pluginPrefStore.set(key, value);
+}
+function getPluginCacheStore() {
+  return pluginCacheStore;
+}
+function setPluginCache(key, value) {
+  pluginCacheStore.set(key, value);
+}
+function snapshotCacheEntries() {
+  const result = [];
+  for (const [key, value] of pluginCacheStore) {
+    result.push({ key, value });
+  }
+  return result;
+}
+var prefChangeListeners = /* @__PURE__ */ new Map();
+function subscribeToPrefChanges(key, cb) {
+  let listeners = prefChangeListeners.get(key);
+  if (listeners === void 0) {
+    listeners = /* @__PURE__ */ new Set();
+    prefChangeListeners.set(key, listeners);
+  }
+  listeners.add(cb);
+  return function unsubscribe() {
+    listeners.delete(cb);
+    if (listeners.size === 0) {
+      prefChangeListeners.delete(key);
+    }
+  };
+}
+function broadcastPrefChange(key) {
+  const listeners = prefChangeListeners.get(key);
+  if (listeners === void 0) return;
+  for (const cb of listeners) {
+    cb();
+  }
+}
+function resolveFilesBaseUrl(resId, token) {
+  return `/api/resources/${resId}/files/${encodeURIComponent(token)}/`;
+}
+function buildFileUrl(resId, filename, token, variant) {
+  const url = `/api/resources/${resId}/files/${encodeURIComponent(token)}/${encodeURIComponent(filename)}`;
+  if (variant === "preview") {
+    return `${url}?size=preview`;
+  }
+  if (variant !== void 0 && variant !== "original") {
+    return `${url}?${imageVariantQuery(variant)}`;
+  }
+  return url;
+}
+function buildFrameUrl(resId, filename, timeMs, token) {
+  const time = String(Math.max(0, Math.round(timeMs)));
+  return `/api/resources/${resId}/frame/${encodeURIComponent(token)}/${encodeURIComponent(filename)}/${time}`;
+}
+function buildAssetUrl(pluginId, path, token) {
+  return `/api/plugin-assets/${encodeURIComponent(pluginId)}/${encodeURIComponent(
+    token
+  )}/${encodeURIComponent(path)}`;
+}
+
+// src/runtime.ts
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function extractThemePayload(data) {
+  if (!isRecord3(data)) {
+    return {
+      resolvedTheme: void 0,
+      palette: void 0,
+      iconStyle: void 0
+    };
+  }
+  return {
+    resolvedTheme: typeof data.resolvedTheme === "string" ? data.resolvedTheme : void 0,
+    palette: typeof data.palette === "string" ? data.palette : void 0,
+    iconStyle: typeof data.iconStyle === "string" ? data.iconStyle : void 0
+  };
+}
+function extractFontsPayload(data) {
+  if (!isRecord3(data) || typeof data.family !== "string") return void 0;
+  const cssPaths = Array.isArray(data.cssPaths) ? data.cssPaths.filter((p) => typeof p === "string") : [];
+  return { family: data.family, cssPaths };
+}
+function extractPrefPayload(data) {
+  if (!isRecord3(data)) return void 0;
+  const key = data.key;
+  if (typeof key !== "string") return void 0;
+  return {
+    key,
+    value: typeof data.value === "string" ? data.value : void 0
+  };
+}
+function createIframeHostAPI(ctx) {
+  const host = ensureHostBridge().withScope(ctx.resId);
+  seedPluginStores(ctx);
+  function logInfo(message, data) {
+    host.request("logInfo", { message, data }).catch(() => {
+    });
+  }
+  function logWarn(message, data) {
+    host.request("logWarn", { message, data }).catch(() => {
+    });
+  }
+  function logError(message, data) {
+    host.request("logError", { message, data }).catch(() => {
+    });
+  }
+  function listFiles() {
+    return host.request("listFiles");
+  }
+  function readFile(path, range) {
+    return host.request("readFile", { path, range });
+  }
+  function resolveFileUrl(filename, variant) {
+    return buildFileUrl(ctx.resId, filename, ctx.fileToken, variant);
+  }
+  function resolveExtractedUrl(path) {
+    return `/api/resources/${ctx.resId}/extracted/${encodeURIComponent(
+      ctx.fileToken
+    )}/${encodeURIComponent(path)}`;
+  }
+  function extractProgressUrl() {
+    return `/api/resources/${ctx.resId}/extract-progress/${encodeURIComponent(
+      ctx.fileToken
+    )}/`;
+  }
+  function resolveBaseUrl() {
+    return resolveFilesBaseUrl(ctx.resId, ctx.fileToken);
+  }
+  function resolveFrameUrl(filename, timeMs) {
+    return buildFrameUrl(ctx.resId, filename, timeMs, ctx.fileToken);
+  }
+  function listMessages() {
+    return host.request("listMessages");
+  }
+  function createMessage(input) {
+    return host.request("createMessage", {
+      body: input.body,
+      anchor: input.anchor === void 0 ? void 0 : { data: input.anchor }
+    });
+  }
+  function listDanmaku(filter) {
+    return host.request("listDanmaku", { filter });
+  }
+  function createDanmaku(input) {
+    return host.request("createDanmaku", {
+      text: input.text,
+      anchor: { data: input.anchor },
+      mode: input.mode
+    });
+  }
+  function getPref(key) {
+    return getPluginPrefStore().get(key) ?? void 0;
+  }
+  function setPref(key, value) {
+    setPluginPref(key, value);
+    broadcastPrefChange(key);
+    host.request("setPref", { key, value }).catch(() => {
+    });
+  }
+  function getCache(key) {
+    return getPluginCacheStore().get(key) ?? void 0;
+  }
+  function setCache(key, value) {
+    setPluginCache(key, value);
+    host.request("setCache", { key, value }).catch(() => {
+    });
+  }
+  function listCache() {
+    return snapshotCacheEntries();
+  }
+  function invalidate(target) {
+    return host.request("invalidate", { target });
+  }
+  function download(request) {
+    return host.request("download", request);
+  }
+  function resolveAssetUrl(path) {
+    if (ctx.assetToken.length === 0) {
+      throw new Error(
+        'resolveAssetUrl() \u2014 the plugin has no asset token: declare "download": true in the manifest and reload the preview'
+      );
+    }
+    return buildAssetUrl(ctx.pluginId, path, ctx.assetToken);
+  }
+  function deleteAsset(path) {
+    return host.request("deleteAsset", { path });
+  }
+  function onAnchorJump(cb) {
+    return host.subscribe("anchorJump", cb);
+  }
+  return {
+    logInfo,
+    logWarn,
+    logError,
+    resource: {
+      id: ctx.resId,
+      name: ctx.resName,
+      sourceMeta: ctx.sourceMeta,
+      searchMeta: ctx.searchMeta,
+      fileStats: ctx.fileStats,
+      contentPluginId: ctx.contentPluginId
+    },
+    listFiles,
+    readFile,
+    resolveFileUrl,
+    resolveExtractedUrl,
+    extractProgressUrl,
+    resolveBaseUrl,
+    resolveFrameUrl,
+    download,
+    resolveAssetUrl,
+    deleteAsset,
+    listMessages,
+    createMessage,
+    listDanmaku,
+    createDanmaku,
+    getPref,
+    setPref,
+    getCache,
+    setCache,
+    listCache,
+    invalidate,
+    onAnchorJump
+  };
+}
+
+export { PROTOCOL_VERSION, applyFonts, applyTheme, booleanCodec, broadcastPrefChange, createIframeHostAPI, createWebPluginAPI, ensureHostBridge, extractFontsPayload, extractPrefPayload, extractThemePayload, getPluginCacheStore, getPluginContext, getPluginPrefStore, getVisibilitySnapshot, hostPushKeys, invalidatePushKeys, isRecord, jsonCodec, mountPlugin, numberCodec, pluginMethods, pluginThemePalettes, seedPluginStores, setPluginCache, setPluginPref, snapshotCacheEntries, subscribeToPrefChanges, subscribeToVisibility };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map