@preprio/toolkit 0.5.0-rc.2 → 0.5.0-rc.3

package/dist/chunk-6WY3MWCX.js

@@ -0,0 +1,246 @@
+import {
+  isAllowedEditorOrigin
+} from "./chunk-URXSDJOU.js";
+import {
+  indexSnapshot,
+  isLiveFieldChange,
+  parseEditTarget,
+  parseListEntries,
+  patchSnapshot,
+  syncListSnapshot
+} from "./chunk-42Z2VW7G.js";
+import {
+  createScopedLogger,
+  getTrustedParentOrigin,
+  sendPreprEvent
+} from "./chunk-S3VT4UWM.js";
+
+// src/core/live-preview/bridge-events.ts
+var debug = createScopedLogger("live-preview:bridge");
+function createLiveBridge(store, options = {}) {
+  let parentOrigin = null;
+  const onMessage = (evt) => {
+    const data = evt?.data;
+    if (data?.event === "prepr:initVE" && !parentOrigin) {
+      if (isAllowedEditorOrigin(evt.origin, options.allowedEditorOrigins?.())) {
+        parentOrigin = evt.origin;
+      } else {
+        debug.warn("ignored live preview handshake from origin", evt.origin);
+      }
+      return;
+    }
+    const trusted = parentOrigin ?? getTrustedParentOrigin();
+    if (!trusted || evt.origin !== trusted) return;
+    if (data?.event === "prepr:fieldChange") {
+      if (typeof data.itemId === "string" && typeof data.field === "string" && data.field && isLiveFieldChange(data.field, data.value)) {
+        const edit = parseEditTarget(data.edit);
+        if (edit) store.pushPatch(data.itemId, data.field, data.value, edit);
+        else store.pushPatch(data.itemId, data.field, data.value);
+      } else {
+        debug.log("dropped malformed fieldChange", data);
+      }
+      return;
+    }
+    if (data?.event === "prepr:listChange") {
+      const list = parseListEntries(data.entries);
+      if (typeof data.itemId === "string" && typeof data.field === "string" && data.field && list) {
+        store.pushList(data.itemId, data.field, list);
+      } else {
+        debug.log("dropped malformed listChange", data);
+      }
+      return;
+    }
+    if (data?.event === "prepr:itemChanged") {
+      if (typeof data.itemId === "string") {
+        store.invalidate(data.itemId);
+      } else {
+        debug.log("dropped malformed itemChanged", data);
+      }
+    }
+  };
+  return {
+    start() {
+      window.addEventListener("message", onMessage);
+      sendPreprEvent(
+        "live_ready",
+        options.strictMode?.() ? { strictMode: true } : void 0,
+        { allowUntrustedTarget: true }
+      );
+    },
+    stop() {
+      window.removeEventListener("message", onMessage);
+    }
+  };
+}
+
+// src/core/live-preview/live-store.ts
+var debug2 = createScopedLogger("live-preview");
+var INVALIDATE_DEBOUNCE_MS = 150;
+var MAX_LOG_ENTRIES = 500;
+function withPatch(log, patch) {
+  let previous = -1;
+  for (let i = log.length - 1; i >= 0; i--) {
+    const p = log[i];
+    if (p.type === patch.type && p.itemId === patch.itemId && p.field === patch.field) {
+      previous = i;
+      break;
+    }
+  }
+  if (previous === -1) return [...log, patch];
+  const since = log.slice(previous + 1);
+  const listPrefix = `${patch.field}.`;
+  const dependsOnPosition = since.some(
+    (p) => p.type === "list" || patch.type === "list" && p.itemId === patch.itemId && p.field.startsWith(listPrefix)
+  );
+  if (dependsOnPosition) return [...log, patch];
+  return [...log.slice(0, previous), ...since, patch];
+}
+function createLiveStore(options = {}) {
+  const accepts = (patch) => options.accept ? options.accept(patch) : true;
+  const entries = /* @__PURE__ */ new Set();
+  const invalidateListeners = /* @__PURE__ */ new Set();
+  const pendingInvalidates = /* @__PURE__ */ new Map();
+  let defaultFetcher = null;
+  let log = [];
+  const logListeners = /* @__PURE__ */ new Set();
+  function record(patch) {
+    log = withPatch(log, patch).slice(-MAX_LOG_ENTRIES);
+    logListeners.forEach((fn) => fn(log));
+  }
+  function notify(entry) {
+    entry.listeners.forEach((fn) => fn());
+  }
+  async function refetch(entry) {
+    const fetcher = entry.opts.fetcher ?? defaultFetcher;
+    if (!fetcher || entry.opts.query == null) return;
+    const token = ++entry.fetchToken;
+    try {
+      const result = await fetcher(entry.opts.query, entry.opts.variables);
+      if (token !== entry.fetchToken || !entries.has(entry)) return;
+      entry.snapshot = result;
+      entry.index = indexSnapshot(result);
+      notify(entry);
+    } catch (error) {
+      debug2.log("refetch failed, keeping previous snapshot", error);
+    }
+  }
+  function runInvalidate(itemId) {
+    pendingInvalidates.delete(itemId);
+    invalidateListeners.forEach((fn) => fn(itemId));
+    for (const entry of entries) {
+      if (entry.index.has(itemId)) void refetch(entry);
+    }
+  }
+  return {
+    register(data, opts = {}) {
+      const entry = {
+        snapshot: data,
+        index: indexSnapshot(data),
+        opts,
+        listeners: /* @__PURE__ */ new Set(),
+        fetchToken: 0
+      };
+      for (const patch of log) {
+        if (patch.type === "field") {
+          entry.snapshot = patchSnapshot(
+            entry.snapshot,
+            entry.index,
+            patch.itemId,
+            patch.field,
+            patch.value
+          );
+        } else {
+          const next = syncListSnapshot(
+            entry.snapshot,
+            entry.index,
+            patch.itemId,
+            patch.field,
+            patch.entries
+          );
+          if (next !== entry.snapshot) {
+            entry.snapshot = next;
+            entry.index = indexSnapshot(next);
+          }
+        }
+      }
+      entries.add(entry);
+      return {
+        getSnapshot: () => entry.snapshot,
+        subscribe(fn) {
+          entry.listeners.add(fn);
+          return () => entry.listeners.delete(fn);
+        },
+        unregister() {
+          entry.listeners.clear();
+          entries.delete(entry);
+        }
+      };
+    },
+    pushPatch(itemId, field, value, edit) {
+      const patch = edit ? { type: "field", itemId, field, value, edit } : { type: "field", itemId, field, value };
+      if (!accepts(patch)) return;
+      record(patch);
+      for (const entry of entries) {
+        const next = patchSnapshot(
+          entry.snapshot,
+          entry.index,
+          itemId,
+          field,
+          value
+        );
+        if (next !== entry.snapshot) {
+          entry.snapshot = next;
+          notify(entry);
+        }
+      }
+    },
+    pushList(itemId, field, list) {
+      const patch = { type: "list", itemId, field, entries: list };
+      if (!accepts(patch)) return;
+      record(patch);
+      for (const entry of entries) {
+        const next = syncListSnapshot(
+          entry.snapshot,
+          entry.index,
+          itemId,
+          field,
+          list
+        );
+        if (next !== entry.snapshot) {
+          entry.snapshot = next;
+          entry.index = indexSnapshot(next);
+          notify(entry);
+        }
+      }
+    },
+    invalidate(itemId) {
+      if (log.length) {
+        log = [];
+        logListeners.forEach((fn) => fn(log));
+      }
+      const pending = pendingInvalidates.get(itemId);
+      if (pending) clearTimeout(pending);
+      pendingInvalidates.set(
+        itemId,
+        setTimeout(() => runInvalidate(itemId), INVALIDATE_DEBOUNCE_MS)
+      );
+    },
+    setFetcher(fetcher) {
+      defaultFetcher = fetcher;
+    },
+    onInvalidate(fn) {
+      invalidateListeners.add(fn);
+      return () => invalidateListeners.delete(fn);
+    },
+    getLog: () => log,
+    onLogChange(fn) {
+      logListeners.add(fn);
+      return () => logListeners.delete(fn);
+    }
+  };
+}
+
+export {
+  createLiveBridge,
+  createLiveStore
+};

package/dist/chunk-MDAV2FLM.js

@@ -0,0 +1,26 @@
+// src/version.ts
+var VERSION = "0.5.0-rc.3";
+
+// src/core/features.ts
+function isEnabled(config) {
+  if (typeof config === "boolean") return config;
+  return config?.enabled ?? true;
+}
+function resolveFeatures(features) {
+  return {
+    segments: isEnabled(features?.segments),
+    abTesting: isEnabled(features?.abTesting),
+    editMode: isEnabled(features?.editMode)
+  };
+}
+var ALL_FEATURES_ENABLED = Object.freeze({
+  segments: true,
+  abTesting: true,
+  editMode: true
+});
+
+export {
+  VERSION,
+  resolveFeatures,
+  ALL_FEATURES_ENABLED
+};