@preprio/toolkit 0.5.0-rc.2 → 0.6.0-alpha.0

package/dist/chunk-DGZA7KX7.js

@@ -0,0 +1,172 @@
+// src/version.ts
+var VERSION = "0.6.0-alpha.0";
+
+// 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
+});
+
+// src/core/stega/clean.ts
+import { vercelStegaClean, vercelStegaDecode } from "@vercel/stega";
+
+// src/core/utils.ts
+var trustedParentOrigin = null;
+function setTrustedParentOrigin(origin) {
+  trustedParentOrigin = origin;
+}
+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}]`
+  });
+}
+function throttle(func, delay) {
+  let timeoutId = null;
+  let lastExecTime = 0;
+  const throttledFunc = ((...args) => {
+    const currentTime = Date.now();
+    const timeSinceLastExec = currentTime - lastExecTime;
+    if (timeSinceLastExec >= delay) {
+      func(...args);
+      lastExecTime = currentTime;
+    } else {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = setTimeout(() => {
+        func(...args);
+        lastExecTime = Date.now();
+        timeoutId = null;
+      }, delay - timeSinceLastExec);
+    }
+  });
+  throttledFunc.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return throttledFunc;
+}
+function createElementCache(query, ttl = 1e3) {
+  let cache = null;
+  let lastCacheTime = 0;
+  return () => {
+    const now = Date.now();
+    if (!cache || now - lastCacheTime > ttl) {
+      cache = document.querySelectorAll(query);
+      lastCacheTime = now;
+    }
+    return cache;
+  };
+}
+
+// src/core/stega/clean.ts
+var debug = createScopedLogger("stega:clean");
+function stegaClean(text) {
+  if (!text) return text;
+  return vercelStegaClean(text);
+}
+function decodeStega(str) {
+  if (!str) return null;
+  try {
+    const decoded = vercelStegaDecode(str);
+    if (decoded?.href) {
+      return decoded;
+    }
+  } catch (error) {
+    debug.log("error decoding stega data", error);
+    const match = str.match(/{"origin.*?}/);
+    if (match) {
+      try {
+        const decodedMatch = vercelStegaDecode(match[0]);
+        if (decodedMatch?.href) {
+          return decodedMatch;
+        }
+      } catch (innerError) {
+        debug.log("error decoding stega regex match", innerError);
+      }
+    }
+  }
+  return null;
+}
+
+export {
+  VERSION,
+  resolveFeatures,
+  ALL_FEATURES_ENABLED,
+  setTrustedParentOrigin,
+  sendPreprEvent,
+  initDebugLogger,
+  createScopedLogger,
+  throttle,
+  createElementCache,
+  stegaClean,
+  decodeStega
+};

package/dist/chunk-YR7P4IWE.js

@@ -0,0 +1,187 @@
+import {
+  VERSION,
+  resolveFeatures
+} from "./chunk-DGZA7KX7.js";
+
+// src/core/personalization.ts
+var PERSONALIZED_VARY = /\bPrepr-(Segments|ABTesting)/i;
+function isPersonalizedResponse(source) {
+  const headers = "headers" in source ? source.headers : source;
+  return PERSONALIZED_VARY.test(headers.get("vary") ?? "");
+}
+
+// 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 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 {
+  isPersonalizedResponse,
+  PreprError,
+  getPreprUUIDFromHeaders,
+  getActiveSegmentFromHeaders,
+  getActiveVariantFromHeaders,
+  getPreprHeadersFromHeaders,
+  validatePreprToken,
+  extractAccessToken,
+  getPreprEnvironmentSegments,
+  getToolbarPropsFromHeaders
+};