@preprio/toolkit 0.4.3 → 0.5.0-rc.10

package/dist/chunk-S3VT4UWM.js

@@ -0,0 +1,75 @@
+// src/core/utils.ts
+var trustedParentOrigin = null;
+function setTrustedParentOrigin(origin) {
+  trustedParentOrigin = origin;
+}
+function getTrustedParentOrigin() {
+  return trustedParentOrigin;
+}
+function sendPreprEvent(event, data, options) {
+  if (typeof window !== "undefined") {
+    const message = {
+      name: "prepr_preview_bar",
+      event,
+      ...data
+    };
+    window.dispatchEvent(
+      new CustomEvent("prepr_preview_bar", { detail: message })
+    );
+    if (window.parent && window.parent !== window) {
+      if (trustedParentOrigin) {
+        window.parent.postMessage(message, trustedParentOrigin);
+      } else if (options?.allowUntrustedTarget) {
+        window.parent.postMessage(message, "*");
+      }
+    }
+  }
+}
+var DebugLogger = class {
+  constructor(options) {
+    this.options = {
+      prefix: "[Prepr]",
+      ...options
+    };
+  }
+  // A local `enabled` wins; otherwise defer to the global logger so scoped
+  // loggers created before initDebugLogger() still pick up the setting.
+  isEnabled() {
+    if (this.options.enabled !== void 0) {
+      return this.options.enabled;
+    }
+    return globalDebugLogger?.options?.enabled ?? false;
+  }
+  log(message, ...args) {
+    if (!this.isEnabled()) return;
+    const prefix = this.options.prefix;
+    console.log(`${prefix} ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    if (!this.isEnabled()) return;
+    const prefix = this.options.prefix;
+    console.warn(`${prefix} ${message}`, ...args);
+  }
+  error(message, ...args) {
+    if (!this.isEnabled()) return;
+    const prefix = this.options.prefix;
+    console.error(`${prefix} ${message}`, ...args);
+  }
+};
+var globalDebugLogger = null;
+function initDebugLogger(enabled = false) {
+  globalDebugLogger = new DebugLogger({ enabled });
+}
+function createScopedLogger(scopeName) {
+  return new DebugLogger({
+    prefix: `[Prepr][${scopeName}]`
+  });
+}
+
+export {
+  setTrustedParentOrigin,
+  getTrustedParentOrigin,
+  sendPreprEvent,
+  initDebugLogger,
+  createScopedLogger
+};

package/dist/chunk-TBBU3LDD.js

@@ -0,0 +1,184 @@
+import {
+  VERSION,
+  resolveFeatures
+} from "./chunk-F46GJS6Y.js";
+
+// src/core/server.ts
+var PreprError = class extends Error {
+  constructor(message, code, context, originalError) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.originalError = originalError;
+    this.name = "PreprError";
+  }
+};
+function getPreprUUIDFromHeaders(headers) {
+  return headers.get("prepr-customer-id");
+}
+function getActiveSegmentFromHeaders(headers) {
+  return headers.get("Prepr-Segments");
+}
+function getActiveVariantFromHeaders(headers) {
+  return headers.get("Prepr-ABtesting");
+}
+var PREVIEW_PACKAGE_PART = /(?:^|;)\s*preview=true\s*(?:;|$)/;
+function isPreviewFromHeaders(headers) {
+  return PREVIEW_PACKAGE_PART.test(headers.get("Prepr-Package") ?? "");
+}
+var PREPR_HEADER_KEYS = [
+  "prepr-customer-id",
+  "Prepr-Segments",
+  "Prepr-ABtesting",
+  "Prepr-Preview-Bar",
+  "Prepr-Context-utm_source",
+  "Prepr-Context-utm_medium",
+  "Prepr-Context-utm_term",
+  "Prepr-Context-utm_content",
+  "Prepr-Context-utm_campaign",
+  "Prepr-Context-initial_referral",
+  "Prepr-Visitor-IP",
+  "Prepr-Hubspot-Id",
+  "Prepr-Customer-Id-Created",
+  "User-Agent",
+  "Prepr-Package"
+];
+function getPreprHeadersFromHeaders(headers) {
+  const preprHeaders = {};
+  const copy = (key) => {
+    const value = headers.get(key);
+    if (value !== null) {
+      preprHeaders[key] = value;
+    }
+  };
+  for (const key of PREPR_HEADER_KEYS) {
+    copy(key);
+  }
+  return preprHeaders;
+}
+function validatePreprToken(token) {
+  if (!token) {
+    throw new PreprError(
+      "Token is required",
+      "MISSING_TOKEN",
+      "validatePreprToken"
+    );
+  }
+  if (!token.startsWith("https://")) {
+    throw new PreprError(
+      "Token must be a valid HTTPS URL",
+      "INVALID_TOKEN",
+      "validatePreprToken"
+    );
+  }
+}
+function extractAccessToken(graphqlUrl) {
+  let url;
+  try {
+    url = new URL(graphqlUrl);
+  } catch (error) {
+    throw new PreprError(
+      "Token must be a valid URL",
+      "INVALID_TOKEN",
+      "extractAccessToken",
+      error instanceof Error ? error : new Error(String(error))
+    );
+  }
+  if (url.hostname !== "graphql.prepr.io") {
+    throw new PreprError(
+      "Token must be a graphql.prepr.io URL",
+      "INVALID_TOKEN",
+      "extractAccessToken"
+    );
+  }
+  const pathParts = url.pathname.split("/");
+  const token = pathParts[pathParts.length - 1];
+  if (!token) {
+    throw new PreprError(
+      "Token URL is missing an access token segment",
+      "INVALID_TOKEN",
+      "extractAccessToken"
+    );
+  }
+  return token;
+}
+async function getPreprEnvironmentSegments(token) {
+  validatePreprToken(token);
+  try {
+    const response = await fetch(token, {
+      headers: {
+        "Prepr-Package": `@preprio/toolkit@${VERSION}`,
+        // Duplicates the version in Prepr-Package. It keeps the User-Agent
+        // format used by `@preprio/prepr-nextjs`, for Prepr API consumers that
+        // still identify the toolbar by that string.
+        "User-Agent": `Prepr-Preview-Bar/${VERSION}`,
+        "Content-Type": "application/json"
+      },
+      method: "POST",
+      body: JSON.stringify({
+        query: `{
+                _Segments {
+                    _id
+                    name
+                }
+            }`
+      })
+    });
+    if (!response.ok) {
+      throw new PreprError(
+        `HTTP ${response.status}: ${response.statusText}`,
+        "HTTP_ERROR",
+        "getPreprEnvironmentSegments"
+      );
+    }
+    const json = await response.json();
+    if (!json || !json.data || !json.data._Segments) {
+      throw new PreprError(
+        "Invalid response format from Prepr API",
+        "INVALID_RESPONSE",
+        "getPreprEnvironmentSegments"
+      );
+    }
+    return json.data._Segments;
+  } catch (error) {
+    if (error instanceof PreprError) {
+      throw error;
+    }
+    throw new PreprError(
+      "Failed to fetch segments from Prepr API",
+      "FETCH_ERROR",
+      "getPreprEnvironmentSegments",
+      error instanceof Error ? error : new Error(String(error))
+    );
+  }
+}
+async function getToolbarPropsFromHeaders(headers, token, features) {
+  const resolved = resolveFeatures(features);
+  let segments = [];
+  if (resolved.segments) {
+    try {
+      segments = await getPreprEnvironmentSegments(token);
+    } catch {
+      segments = [];
+    }
+  }
+  return {
+    activeSegment: resolved.segments ? getActiveSegmentFromHeaders(headers) : null,
+    activeVariant: resolved.abTesting ? getActiveVariantFromHeaders(headers) : null,
+    segments,
+    data: segments
+  };
+}
+
+export {
+  PreprError,
+  getPreprUUIDFromHeaders,
+  getActiveSegmentFromHeaders,
+  getActiveVariantFromHeaders,
+  isPreviewFromHeaders,
+  getPreprHeadersFromHeaders,
+  validatePreprToken,
+  extractAccessToken,
+  getPreprEnvironmentSegments,
+  getToolbarPropsFromHeaders
+};

package/dist/chunk-URXSDJOU.js

@@ -0,0 +1,356 @@
+import {
+  createScopedLogger,
+  sendPreprEvent,
+  setTrustedParentOrigin
+} from "./chunk-S3VT4UWM.js";
+
+// src/core/locales/de.json
+var de_default = {
+  common: {
+    viewingAs: "Ansicht als:",
+    user: "Benutzer",
+    off: "Aus",
+    on: "An",
+    reset: "Zur\xFCcksetzen",
+    toolbar: "Symbolleiste"
+  },
+  adaptiveContent: {
+    adaptiveContent: "Adaptive Inhalte",
+    enablePreview: "Vorschaumodus",
+    segment: "Segment",
+    ABVariant: "A/B-Variante",
+    chooseSegment: "Segment w\xE4hlen",
+    searchSegments: "Segmente suchen",
+    none: "Keine Segmente",
+    allOtherUsers: "Alle anderen Benutzer",
+    offDescription: "Die Website als echter Benutzer ansehen (Cookies verwenden)",
+    onDescription: "Mit der Symbolleiste Segmente und A/B-Varianten simulieren"
+  },
+  editingTools: {
+    editingTools: "Bearbeitungswerkzeuge",
+    editMode: "Bearbeitungsmodus",
+    ariaCloseEditMode: "Bearbeitungsmodus schlie\xDFen"
+  },
+  visualEditor: {
+    edit: "Bearbeiten",
+    otherItem: "anderes Element",
+    linkedItem: "verkn\xFCpftes Element"
+  }
+};
+
+// src/core/locales/en.json
+var en_default = {
+  common: {
+    viewingAs: "Viewing as:",
+    user: "User",
+    off: "Off",
+    on: "On",
+    reset: "Reset",
+    toolbar: "Toolbar"
+  },
+  adaptiveContent: {
+    adaptiveContent: "Adaptive content",
+    enablePreview: "Preview mode",
+    segment: "Segment",
+    ABVariant: "A/B variant",
+    chooseSegment: "Choose segment",
+    searchSegments: "Search segments",
+    none: "No segments",
+    allOtherUsers: "All other users",
+    offDescription: "View the site as a real user (use cookies)",
+    onDescription: "Use the toolbar to simulate segments and A/B variants"
+  },
+  editingTools: {
+    editingTools: "Editing tools",
+    editMode: "Edit mode",
+    ariaCloseEditMode: "Close edit mode"
+  },
+  visualEditor: {
+    edit: "Edit",
+    otherItem: "other item",
+    linkedItem: "linked item"
+  }
+};
+
+// src/core/locales/fr.json
+var fr_default = {
+  common: {
+    viewingAs: "Affichage en tant que :",
+    user: "Utilisateur",
+    off: "D\xE9sactiv\xE9",
+    on: "Activ\xE9",
+    reset: "R\xE9initialiser",
+    toolbar: "Barre d'outils"
+  },
+  adaptiveContent: {
+    adaptiveContent: "Contenu adaptatif",
+    enablePreview: "Mode aper\xE7u",
+    segment: "Segment",
+    ABVariant: "Variante A/B",
+    chooseSegment: "Choisir un segment",
+    searchSegments: "Rechercher des segments",
+    none: "Aucun segment",
+    allOtherUsers: "Tous les autres utilisateurs",
+    offDescription: "Voir le site comme un vrai utilisateur (utiliser les cookies)",
+    onDescription: "Utilisez la barre d'outils pour simuler des segments et des variantes A/B"
+  },
+  editingTools: {
+    editingTools: "Outils d'\xE9dition",
+    editMode: "Mode \xE9dition",
+    ariaCloseEditMode: "Fermer le mode \xE9dition"
+  },
+  visualEditor: {
+    edit: "Modifier",
+    otherItem: "autre \xE9l\xE9ment",
+    linkedItem: "\xE9l\xE9ment li\xE9"
+  }
+};
+
+// src/core/locales/nl.json
+var nl_default = {
+  common: {
+    viewingAs: "Bekijken als:",
+    user: "Gebruiker",
+    off: "Uit",
+    on: "Aan",
+    reset: "Resetten",
+    toolbar: "Toolbar"
+  },
+  adaptiveContent: {
+    adaptiveContent: "Adaptieve inhoud",
+    enablePreview: "Preview modus",
+    segment: "Segment",
+    ABVariant: "A/B-variant",
+    chooseSegment: "Kies segment",
+    searchSegments: "Zoek segmenten",
+    none: "Geen segmenten",
+    allOtherUsers: "Alle andere gebruikers",
+    offDescription: "Bekijk de site als een echte gebruiker (gebruik cookies)",
+    onDescription: "Gebruik de werkbalk om segmenten en A/B-varianten te simuleren"
+  },
+  editingTools: {
+    editingTools: "Editing Tools",
+    editMode: "Edit mode",
+    ariaCloseEditMode: "Edit mode sluiten"
+  },
+  visualEditor: {
+    edit: "Bewerken",
+    otherItem: "ander item",
+    linkedItem: "gekoppeld item"
+  }
+};
+
+// src/core/i18n.ts
+var dictionaries = {
+  en: en_default,
+  nl: nl_default,
+  fr: fr_default,
+  de: de_default
+};
+var LOCALES = Object.keys(dictionaries);
+function isLocale(value) {
+  return typeof value === "string" && value in dictionaries;
+}
+function getDict(locale) {
+  return isLocale(locale) ? dictionaries[locale] : dictionaries.en;
+}
+function getFromPath(obj, path) {
+  return path.split(".").reduce(
+    (acc, key) => acc && typeof acc === "object" ? acc[key] : void 0,
+    obj
+  );
+}
+function format(message, vars) {
+  if (!vars) return message;
+  return Object.keys(vars).reduce(
+    (acc, k) => acc.replace(new RegExp(`\\{${k}\\}`, "g"), String(vars[k])),
+    message
+  );
+}
+function t(key, locale, vars) {
+  const dict = getDict(locale);
+  const msg = getFromPath(dict, key);
+  if (typeof msg === "string") return format(msg, vars);
+  return key;
+}
+
+// src/core/iframe-bridge.ts
+var debug = createScopedLogger("iframe-bridge");
+var MAX_REFERENCES = 500;
+var MAX_HREF_LENGTH = 8192;
+var MAX_ASSETS = 500;
+var MAX_ASSET_KEY_LENGTH = 2048;
+var MAX_ASSET_FIELD_LENGTH = 512;
+function parseIds(value) {
+  if (!Array.isArray(value)) return void 0;
+  return value.slice(0, MAX_REFERENCES).filter((id) => typeof id === "string" && id.length > 0);
+}
+function parseReferences(value) {
+  if (!Array.isArray(value)) return void 0;
+  const list = [];
+  for (const entry of value.slice(0, MAX_REFERENCES)) {
+    const id = entry?.id;
+    const field = entry?.field;
+    if (typeof id === "string" && id && typeof field === "string" && field) {
+      list.push({ id, field });
+    }
+  }
+  return list;
+}
+function boundedString(value, max) {
+  return typeof value === "string" && value && value.length <= max ? value : void 0;
+}
+function parseAssets(value) {
+  if (!Array.isArray(value)) return void 0;
+  const list = [];
+  for (const entry of value.slice(0, MAX_ASSETS)) {
+    if (!entry || typeof entry !== "object") continue;
+    const raw = entry;
+    const key = boundedString(raw.key, MAX_ASSET_KEY_LENGTH);
+    const field = boundedString(raw.field, MAX_ASSET_FIELD_LENGTH);
+    if (!key || !field) continue;
+    const entryId = boundedString(raw.entryId, MAX_ASSET_FIELD_LENGTH);
+    list.push(entryId ? { key, field, entryId } : { key, field });
+  }
+  return list;
+}
+var EDITOR_BASE_DOMAIN = "prepr.io";
+function isAllowedEditorOrigin(origin, allowed) {
+  if (allowed) {
+    if (allowed.includes("*")) return origin !== "null";
+    return allowed.includes(origin);
+  }
+  let url;
+  try {
+    url = new URL(origin);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "https:" || url.port !== "") return false;
+  const suffix = `.${EDITOR_BASE_DOMAIN}`;
+  if (!url.hostname.endsWith(suffix)) return false;
+  const label = url.hostname.slice(0, -suffix.length);
+  return label.length > 0 && !label.includes(".");
+}
+function createIframeBridge(store, options = {}) {
+  const allowedOrigins = options.allowedEditorOrigins;
+  const onScrollToField = options.onScrollToField;
+  const onHandshake = options.onHandshake;
+  const onReferences = options.onReferences;
+  const onAssets = options.onAssets;
+  const onAllowNavigation = options.onAllowNavigation;
+  let parentOrigin = null;
+  const onKeyDown = (event) => {
+    const key = event.key.toLowerCase();
+    const blocked = (event.ctrlKey || event.metaKey) && ["s", "p", "l"].includes(key);
+    if (blocked) event.preventDefault();
+  };
+  const onMessage = (evt) => {
+    const data = evt?.data;
+    if (data?.event === "prepr:initVE" && !parentOrigin) {
+      if (!isAllowedEditorOrigin(evt.origin, allowedOrigins)) {
+        debug.warn("ignored editor handshake from origin", evt.origin);
+        return;
+      }
+      parentOrigin = evt.origin;
+      setTrustedParentOrigin(parentOrigin);
+      if (data.scrollPosition != null) {
+        const top = data.scrollPosition;
+        setTimeout(() => window.scrollTo(0, top), 1);
+      }
+      store?.set({ previewMode: true, editMode: data.editMode ?? true });
+      const itemId = typeof data.itemId === "string" && data.itemId ? data.itemId : void 0;
+      const referencedIds = parseReferences(data.referencedIds);
+      const componentIds = parseIds(data.componentIds);
+      const uiLocale = isLocale(data.uiLocale) ? data.uiLocale : void 0;
+      const navigationGuard = data.navigationGuard === true;
+      const assets = parseAssets(data.assets);
+      try {
+        onHandshake?.({
+          ...itemId && { itemId },
+          ...referencedIds && { referencedIds },
+          ...componentIds && { componentIds },
+          ...uiLocale && { uiLocale },
+          ...navigationGuard && { navigationGuard },
+          ...assets && { assets }
+        });
+      } catch (error) {
+        debug.warn("handshake handler failed", error);
+      }
+    }
+    if (!parentOrigin || evt.origin !== parentOrigin) return;
+    if (data?.event === "prepr:references") {
+      const assets = parseAssets(data.assets);
+      if (assets) {
+        try {
+          onAssets?.(assets);
+        } catch (error) {
+          debug.warn("assets handler failed", error);
+        }
+      }
+      const referencedIds = parseReferences(data.referencedIds);
+      if (!referencedIds) return;
+      try {
+        onReferences?.(referencedIds, parseIds(data.componentIds));
+      } catch (error) {
+        debug.warn("references handler failed", error);
+      }
+    }
+    if (data?.event === "prepr:getScrollPosition") {
+      const currentScrollY = window.scrollY || document.documentElement.scrollTop;
+      sendPreprEvent("getScrollPosition", { value: currentScrollY });
+    }
+    if (data?.event === "prepr:scrollToField") {
+      if (typeof data.field !== "string" || !data.field) return;
+      if (data.id !== void 0 && typeof data.id !== "string") return;
+      const block = typeof data.block === "number" && Number.isInteger(data.block) ? data.block : void 0;
+      const entryId = typeof data.entryId === "string" && data.entryId ? data.entryId : void 0;
+      const fieldById = typeof data.fieldById === "string" && data.fieldById ? data.fieldById : void 0;
+      try {
+        onScrollToField?.({
+          field: data.field,
+          id: data.id,
+          block,
+          entryId,
+          fieldById
+        });
+      } catch (error) {
+        debug.warn("scrollToField handler failed", error);
+      }
+    }
+    if (data?.event === "prepr:allowNavigation") {
+      const href = data.href;
+      if (typeof href !== "string" || !href || href.length > MAX_HREF_LENGTH) {
+        return;
+      }
+      try {
+        onAllowNavigation?.(href);
+      } catch (error) {
+        debug.warn("allowNavigation handler failed", error);
+      }
+    }
+  };
+  return {
+    start() {
+      const features = store?.get().features;
+      sendPreprEvent("loaded", features ? { features } : void 0, {
+        allowUntrustedTarget: true
+      });
+      window.addEventListener("keydown", onKeyDown);
+      window.addEventListener("message", onMessage);
+    },
+    stop() {
+      window.removeEventListener("keydown", onKeyDown);
+      window.removeEventListener("message", onMessage);
+      parentOrigin = null;
+      setTrustedParentOrigin(null);
+    }
+  };
+}
+
+export {
+  isLocale,
+  t,
+  isAllowedEditorOrigin,
+  createIframeBridge
+};

package/dist/codegen/index.cjs

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/codegen/index.ts
+var codegen_exports = {};
+__export(codegen_exports, {
+  addPreprIds: () => addPreprIds,
+  createPreprIds: () => createPreprIds,
+  preprIds: () => preprIds
+});
+module.exports = __toCommonJS(codegen_exports);
+var import_graphql = require("graphql");
+function field(name) {
+  return { kind: import_graphql.Kind.FIELD, name: { kind: import_graphql.Kind.NAME, value: name } };
+}
+function hasResponseKey(set, key) {
+  return set.selections.some(
+    (s) => s.kind === import_graphql.Kind.FIELD && (s.alias ?? s.name).value === key
+  );
+}
+function addPreprIds(document, schema, options = {}) {
+  const typename = options.typename ?? false;
+  const roots = new Set(
+    [
+      schema.getQueryType(),
+      schema.getMutationType(),
+      schema.getSubscriptionType()
+    ].filter(Boolean)
+  );
+  const typeInfo = new import_graphql.TypeInfo(schema);
+  return (0, import_graphql.visit)(
+    document,
+    (0, import_graphql.visitWithTypeInfo)(typeInfo, {
+      SelectionSet(node) {
+        const type = typeInfo.getParentType();
+        if (!type || !(0, import_graphql.isCompositeType)(type) || roots.has(type)) return;
+        const added = [];
+        if (((0, import_graphql.isObjectType)(type) || (0, import_graphql.isInterfaceType)(type)) && "_id" in type.getFields() && !hasResponseKey(node, "_id")) {
+          added.push(field("_id"));
+        }
+        if (typename && !hasResponseKey(node, "__typename")) {
+          added.push(field("__typename"));
+        }
+        if (!added.length) return;
+        return { ...node, selections: [...added, ...node.selections] };
+      }
+    })
+  );
+}
+function createPreprIds(options = {}) {
+  return {
+    transform({ documents, schema }) {
+      const built = (0, import_graphql.buildASTSchema)(schema, { assumeValidSDL: true });
+      return documents.map(
+        (file) => file.document ? { ...file, document: addPreprIds(file.document, built, options) } : file
+      );
+    }
+  };
+}
+var preprIds = createPreprIds();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addPreprIds,
+  createPreprIds,
+  preprIds
+});