@ai-switch/tauri-plugin-runtime 0.1.0

package/dist/chunk-JSBRDJBE.js

@@ -0,0 +1,30 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};

package/dist/chunk-K5YWIJN6.js

@@ -0,0 +1,389 @@
+import {
+  createRpcPeer,
+  readBootstrapHint,
+  validateConnectMessage
+} from "./chunk-PW7XHHWG.js";
+import {
+  AplgError,
+  satisfiesApiRange,
+  standardCapabilities,
+  validateCapabilityRequest,
+  validateCapabilityResult,
+  validateJson
+} from "./chunk-RKQEK7DY.js";
+import {
+  protocolVersion
+} from "./chunk-WT62GTMC.js";
+
+// src/plugin/client.ts
+function frozenSnapshot(input) {
+  const copy = JSON.parse(JSON.stringify(input));
+  const freeze = (value) => {
+    if (value !== null && typeof value === "object") {
+      Object.values(value).forEach(freeze);
+      Object.freeze(value);
+    }
+  };
+  freeze(copy);
+  return copy;
+}
+function createPluginClient(peer, sessionInfo) {
+  if (!validateJson(sessionInfo).ok) throw new AplgError("E_INVALID_MESSAGE", "Invalid public session information.");
+  const info = frozenSnapshot(sessionInfo);
+  let state = "connected";
+  let opening = 0;
+  const subscriptions = /* @__PURE__ */ new Map();
+  const listeners2 = /* @__PURE__ */ new Set();
+  const earlyEvents = [];
+  let bufferTimer;
+  let removePeerListener = () => {
+  };
+  function setState(next) {
+    if (state === "closed" || state === next) return;
+    state = next;
+    if (next === "closed") {
+      subscriptions.clear();
+      earlyEvents.length = 0;
+      clearTimeout(bufferTimer);
+      bufferTimer = void 0;
+      removePeerListener();
+    }
+    for (const callback of [...listeners2]) {
+      try {
+        callback(next);
+      } catch {
+      }
+    }
+    if (next === "closed") listeners2.clear();
+  }
+  function assertConnected() {
+    if (state === "closed") throw new AplgError("E_SESSION_CLOSED", "The plugin session is closed.");
+    if (state === "disconnected") throw new AplgError("E_HOST_UNAVAILABLE", "The plugin host is disconnected.");
+  }
+  function supports(name, range) {
+    const capability = Object.hasOwn(info.capabilities, name) ? info.capabilities[name] : void 0;
+    return state !== "closed" && Boolean(capability && (range === void 0 || satisfiesApiRange(capability.version, range)));
+  }
+  function requireCapability(name, method) {
+    assertConnected();
+    if (!supports(name) || method !== void 0 && !info.capabilities[name].methods.includes(method)) {
+      throw new AplgError("E_CAPABILITY_UNAVAILABLE", "The requested capability or method is unavailable.");
+    }
+  }
+  async function call(capability, method, params = null, options) {
+    requireCapability(capability, method);
+    const standard = Object.hasOwn(standardCapabilities, capability);
+    if (standard && !validateCapabilityRequest(capability, method, params).ok) {
+      throw new AplgError("E_INVALID_ARGUMENT", "The capability request is invalid.");
+    }
+    const value = await peer.request("capability.call", { capability, method, params }, options);
+    if (state === "closed") throw new AplgError("E_SESSION_CLOSED", "The plugin session is closed.");
+    if (standard && !validateCapabilityResult(capability, method, value).ok) {
+      throw new AplgError("E_INVALID_MESSAGE", "The host returned an invalid capability result.");
+    }
+    return value;
+  }
+  function deliver(event, subscription) {
+    if (event.seq <= subscription.seq) return;
+    if (event.seq !== subscription.seq + 1) {
+      setState("disconnected");
+      setState("connected");
+    }
+    subscription.seq = event.seq;
+    try {
+      subscription.callback(event.payload);
+    } catch {
+    }
+  }
+  function clearExpired() {
+    const now = Date.now();
+    for (let index = earlyEvents.length - 1; index >= 0; index--) if (earlyEvents[index].expires <= now) earlyEvents.splice(index, 1);
+    clearTimeout(bufferTimer);
+    bufferTimer = void 0;
+    if (earlyEvents.length) bufferTimer = setTimeout(clearExpired, Math.max(1, earlyEvents[0].expires - now));
+  }
+  removePeerListener = peer.onEvent((event) => {
+    if (event.kind === "connection") {
+      setState(event.state);
+      return;
+    }
+    if (state !== "connected") return;
+    const subscription = subscriptions.get(event.subscriptionId);
+    if (subscription) {
+      deliver(event, subscription);
+      return;
+    }
+    if (opening > 0 && earlyEvents.length < 32) {
+      earlyEvents.push({ event, expires: Date.now() + 2e3 });
+      if (!bufferTimer) bufferTimer = setTimeout(clearExpired, 2e3);
+    }
+  });
+  return {
+    async ready() {
+      assertConnected();
+      return info;
+    },
+    capabilities: { supports },
+    call,
+    async subscribe(capability, topic, callback) {
+      requireCapability(capability);
+      if (typeof callback !== "function") throw new AplgError("E_INVALID_ARGUMENT", "An event callback is required.");
+      if (subscriptions.size + opening >= 64) throw new AplgError("E_LIMIT_EXCEEDED", "Too many plugin subscriptions.");
+      opening++;
+      try {
+        const value = await peer.request("subscription.open", { capability, topic });
+        if (state === "closed") throw new AplgError("E_SESSION_CLOSED", "The plugin session is closed.");
+        if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).length !== 1 || typeof value.subscriptionId !== "string" || !/^[\x21-\x7e]{1,128}$/.test(value.subscriptionId) || subscriptions.has(value.subscriptionId)) {
+          peer.close(new AplgError("E_INVALID_MESSAGE", "Invalid subscription reply."));
+          throw new AplgError("E_INVALID_MESSAGE", "Invalid subscription reply.");
+        }
+        const id = value.subscriptionId;
+        if (state !== "connected") {
+          void peer.request("subscription.close", { subscriptionId: id }).catch(() => {
+          });
+          assertConnected();
+        }
+        const subscription = { seq: 0, callback };
+        subscriptions.set(id, subscription);
+        clearExpired();
+        for (let index = 0; index < earlyEvents.length; ) {
+          const item = earlyEvents[index];
+          if (item.event.subscriptionId === id) {
+            earlyEvents.splice(index, 1);
+            deliver(item.event, subscription);
+          } else index++;
+        }
+        return () => {
+          if (!subscriptions.delete(id)) return;
+          void peer.request("subscription.close", { subscriptionId: id }).catch(() => {
+          });
+        };
+      } finally {
+        opening--;
+        if (opening === 0) {
+          earlyEvents.length = 0;
+          clearTimeout(bufferTimer);
+          bufferTimer = void 0;
+        }
+      }
+    },
+    onConnectionChange(callback) {
+      if (state === "closed") {
+        callback("closed");
+        return () => {
+        };
+      }
+      listeners2.add(callback);
+      return () => {
+        listeners2.delete(callback);
+      };
+    },
+    storage: {
+      get: (key) => call("aplg.storage", "get", { key }),
+      async set(key, value) {
+        await call("aplg.storage", "set", { key, value });
+      },
+      async remove(key) {
+        await call("aplg.storage", "remove", { key });
+      }
+    },
+    dialog: {
+      async pickDirectory(options = {}) {
+        if (!validateCapabilityRequest("aplg.dialog", "pickDirectory", options).ok) {
+          throw new AplgError("E_INVALID_ARGUMENT", "The directory picker options are invalid.");
+        }
+        return call("aplg.dialog", "pickDirectory", { access: options.access ?? "read" });
+      }
+    }
+  };
+}
+
+// src/plugin/connection.ts
+var client;
+var connecting;
+var ready;
+var currentState = "idle";
+var listeners = /* @__PURE__ */ new Set();
+function closeTransferredPorts(event) {
+  for (const port of event.ports) port.close();
+}
+function connectWindow(target) {
+  if (target.parent === target) return Promise.reject(new AplgError("E_HOST_UNAVAILABLE", "A plugin must be opened by an APLG host."));
+  let hint;
+  try {
+    hint = readBootstrapHint(target.location.href);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  return new Promise((resolve, reject) => {
+    let peer;
+    let settled = false;
+    let handshakeAccepted = false;
+    let removeAckListener = () => {
+    };
+    let removeCloseListener = () => {
+    };
+    const timer = setTimeout(() => fail(new AplgError("E_TIMEOUT", "The plugin host did not complete the handshake.")), 1e4);
+    function clearHandshake() {
+      clearTimeout(timer);
+      target.removeEventListener("message", receive);
+      removeAckListener();
+    }
+    function fail(error) {
+      if (settled) return;
+      settled = true;
+      clearHandshake();
+      target.removeEventListener("pagehide", leave);
+      removeCloseListener();
+      peer?.close(error);
+      reject(error);
+    }
+    function leave() {
+      if (!settled) fail(new AplgError("E_SESSION_CLOSED", "The plugin view was unloaded."));
+      else peer?.close();
+    }
+    function receive(event) {
+      if (event.source !== target.parent || event.origin !== hint.parentOrigin) {
+        closeTransferredPorts(event);
+        return;
+      }
+      const data = event.data;
+      if (data === null || typeof data !== "object" || Array.isArray(data) || !Object.hasOwn(data, "nonce") || data.nonce !== hint.nonce) {
+        closeTransferredPorts(event);
+        return;
+      }
+      if (handshakeAccepted) {
+        closeTransferredPorts(event);
+        return;
+      }
+      let info;
+      try {
+        info = validateConnectMessage(data, hint.nonce);
+        if (event.ports.length !== 1) throw new AplgError("E_PROTOCOL_MISMATCH", "The host must provide exactly one RPC port.");
+      } catch {
+        closeTransferredPorts(event);
+        fail(new AplgError("E_PROTOCOL_MISMATCH", "The bootstrap response was invalid."));
+        return;
+      }
+      handshakeAccepted = true;
+      peer = createRpcPeer(event.ports[0], { maxBytes: info.limits.controlBytes });
+      removeCloseListener = peer.onEvent((message) => {
+        if (message.kind === "connection" && message.state === "closed") {
+          target.removeEventListener("pagehide", leave);
+          if (!settled) fail(new AplgError("E_SESSION_CLOSED", "The host closed during the handshake."));
+          removeCloseListener();
+        }
+      });
+      removeAckListener = peer.onEvent((message) => {
+        if (settled || message.kind !== "connection" || message.state !== "connected") return;
+        try {
+          const connectedClient = createPluginClient(peer, info);
+          try {
+            target.history.replaceState(target.history.state, "", `${target.location.pathname}${target.location.search}${hint.originalHash}`);
+          } catch {
+            target.location.hash = hint.originalHash;
+          }
+          settled = true;
+          clearHandshake();
+          resolve(connectedClient);
+        } catch {
+          fail(new AplgError("E_PROTOCOL_MISMATCH", "The plugin connection could not be initialized."));
+        }
+      });
+      try {
+        peer.sendEvent({ protocol: protocolVersion, kind: "connection", state: "connected" });
+      } catch {
+        fail(new AplgError("E_SESSION_CLOSED", "The handshake port is unavailable."));
+      }
+    }
+    target.addEventListener("message", receive);
+    target.addEventListener("pagehide", leave, { once: true });
+    try {
+      target.parent.postMessage({ channel: "aplg.bootstrap", protocol: protocolVersion, kind: "ready", nonce: hint.nonce }, hint.parentOrigin);
+    } catch {
+      fail(new AplgError("E_HOST_UNAVAILABLE", "The plugin host cannot be reached."));
+    }
+  });
+}
+function getPluginClient() {
+  connecting ??= (typeof window === "undefined" ? Promise.reject(new AplgError("E_HOST_UNAVAILABLE", "A plugin connection requires a browser host.")) : connectWindow(window)).then((value) => {
+    client = value;
+    currentState = "connected";
+    value.onConnectionChange((state) => {
+      currentState = state;
+      for (const callback of [...listeners]) {
+        try {
+          callback(state);
+        } catch {
+        }
+      }
+      if (state === "closed") listeners.clear();
+    });
+    return value;
+  }).catch((error) => {
+    currentState = "closed";
+    for (const callback of [...listeners]) {
+      try {
+        callback("closed");
+      } catch {
+      }
+    }
+    listeners.clear();
+    throw error;
+  });
+  return connecting;
+}
+function connectPlugin() {
+  if (client) return client.ready();
+  ready ??= getPluginClient().then((value) => value.ready());
+  return ready;
+}
+function supportsCapability(name, range) {
+  return client?.capabilities.supports(name, range) ?? false;
+}
+function onConnectionChange(callback) {
+  if (currentState === "closed") {
+    try {
+      callback("closed");
+    } catch {
+    }
+    return () => {
+    };
+  }
+  listeners.add(callback);
+  return () => {
+    listeners.delete(callback);
+  };
+}
+
+// src/plugin/index.ts
+var aplg = {
+  ready: connectPlugin,
+  capabilities: { supports: supportsCapability },
+  async call(capability, method, params, options) {
+    return (await getPluginClient()).call(capability, method, params, options);
+  },
+  async subscribe(capability, topic, callback) {
+    return (await getPluginClient()).subscribe(capability, topic, callback);
+  },
+  onConnectionChange,
+  storage: {
+    async get(key) {
+      return (await getPluginClient()).storage.get(key);
+    },
+    async set(key, value) {
+      return (await getPluginClient()).storage.set(key, value);
+    },
+    async remove(key) {
+      return (await getPluginClient()).storage.remove(key);
+    }
+  },
+  dialog: { async pickDirectory(options) {
+    return (await getPluginClient()).dialog.pickDirectory(options);
+  } }
+};
+
+export {
+  connectPlugin,
+  aplg
+};