@replohq/sdk 0.1.0

package/consent/consent-store.js

@@ -0,0 +1,194 @@
+"use client";
+import { useSyncExternalStore } from "react";
+import { deriveConsentAction } from "./consent-action";
+import { recordConsentAction } from "./consent-actions";
+import {
+  CONSENT_COOKIE_MAX_AGE_SECONDS,
+  CONSENT_COOKIE_NAME,
+  DENIED_CATEGORIES,
+  GRANTED_CATEGORIES,
+  parseConsentCookie,
+  serializeConsentCookieValue
+} from "./cookie";
+const TOGGLEABLE_CATEGORIES = [
+  "analytics",
+  "marketing",
+  "preferences",
+  "sale_of_data"
+];
+const SERVER_SNAPSHOT = Object.freeze({
+  mode: "off",
+  categories: DENIED_CATEGORIES,
+  decidedAt: null
+});
+const listeners = /* @__PURE__ */ new Set();
+let snapshot = null;
+function isConsentMode(value) {
+  return value === "off" || value === "simple" || value === "per-category";
+}
+function resolveMode() {
+  if (typeof window === "undefined") {
+    return "off";
+  }
+  const attribute = document.documentElement.dataset.reploConsentMode;
+  return isConsentMode(attribute) ? attribute : "off";
+}
+const DEFAULT_CONSENT_POLICY_VERSION = 1;
+function computeSnapshot() {
+  if (typeof window === "undefined") {
+    return SERVER_SNAPSHOT;
+  }
+  const mode = resolveMode();
+  const fromCookie = parseConsentCookie(document.cookie);
+  if (fromCookie) {
+    return {
+      mode,
+      categories: {
+        necessary: true,
+        analytics: fromCookie.categories.analytics,
+        marketing: fromCookie.categories.marketing,
+        preferences: fromCookie.categories.preferences,
+        sale_of_data: fromCookie.categories.sale_of_data
+      },
+      decidedAt: fromCookie.decidedAt,
+      consentId: fromCookie.consentId
+    };
+  }
+  return { mode, categories: DENIED_CATEGORIES, decidedAt: null };
+}
+function writeCookie(categories, decidedAt, consentId) {
+  if (typeof document === "undefined") {
+    return;
+  }
+  const value = serializeConsentCookieValue({
+    categories,
+    decidedAt,
+    consentId
+  });
+  document.cookie = `${CONSENT_COOKIE_NAME}=${value}; path=/; max-age=${CONSENT_COOKIE_MAX_AGE_SECONDS}; SameSite=Lax`;
+}
+function notify() {
+  for (const listener of listeners) {
+    listener();
+  }
+}
+function commit({
+  categories,
+  policyVersion = DEFAULT_CONSENT_POLICY_VERSION
+}) {
+  const previous = consentStore.getSnapshot();
+  const decidedAt = Date.now();
+  const consentId = previous.consentId ?? crypto.randomUUID();
+  const resultingCategories = {
+    ...categories,
+    necessary: true
+  };
+  writeCookie(categories, decidedAt, consentId);
+  snapshot = {
+    mode: previous.mode,
+    categories: resultingCategories,
+    decidedAt,
+    consentId
+  };
+  notify();
+  const wasDowngrade = previous.decidedAt !== null && TOGGLEABLE_CATEGORIES.some((category) => {
+    return previous.categories[category] && !categories[category];
+  });
+  const reloadIfDowngraded = () => {
+    if (wasDowngrade && typeof window !== "undefined") {
+      window.location.reload();
+    }
+  };
+  if (previous.mode !== "off") {
+    void recordConsentAction({
+      consentId,
+      action: deriveConsentAction({ previous, next: resultingCategories }),
+      categories: resultingCategories,
+      consentMode: previous.mode,
+      decidedAt,
+      policyVersion
+    }).finally(reloadIfDowngraded);
+  } else {
+    reloadIfDowngraded();
+  }
+}
+const consentStore = {
+  getSnapshot() {
+    if (!snapshot) {
+      snapshot = computeSnapshot();
+    }
+    return snapshot;
+  },
+  getServerSnapshot() {
+    return SERVER_SNAPSHOT;
+  },
+  subscribe(listener) {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  },
+  /** Grant every consent category. */
+  accept(options = {}) {
+    commit({
+      categories: GRANTED_CATEGORIES,
+      policyVersion: options.policyVersion
+    });
+  },
+  /** Deny every non-necessary category. */
+  reject(options = {}) {
+    commit({
+      categories: DENIED_CATEGORIES,
+      policyVersion: options.policyVersion
+    });
+  },
+  /** Set a subset of categories, leaving the rest at their current value. */
+  updateCategories({
+    next,
+    policyVersion
+  }) {
+    const current = consentStore.getSnapshot().categories;
+    commit({
+      categories: { ...current, ...next, necessary: true },
+      policyVersion
+    });
+  },
+  /** Test-only: reset cached state so the next read recomputes. */
+  reset() {
+    snapshot = null;
+  }
+};
+function useConsent(options = {}) {
+  const policyVersion = options.version;
+  const state = useSyncExternalStore(
+    consentStore.subscribe,
+    consentStore.getSnapshot,
+    consentStore.getServerSnapshot
+  );
+  return {
+    ...state,
+    accept: () => consentStore.accept({ policyVersion }),
+    reject: () => consentStore.reject({ policyVersion }),
+    updateCategories: (next) => {
+      consentStore.updateCategories({ next, policyVersion });
+    }
+  };
+}
+function isConsentAllowed({
+  state,
+  requiredConsent
+}) {
+  if (state.mode === "off") {
+    return true;
+  }
+  if (requiredConsent.length === 0) {
+    return true;
+  }
+  return requiredConsent.every((category) => state.categories[category]);
+}
+export {
+  consentStore,
+  isConsentAllowed,
+  useConsent
+};
+//# sourceMappingURL=consent-store.js.map

package/consent/consent-store.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../consent/consent-store.ts"],
+  "sourcesContent": ["\"use client\";\n\nimport type { ConsentCategory, ConsentMode } from \"schemas/generated/consent\";\nimport type { ConsentCategories } from \"./cookie\";\n\nimport { useSyncExternalStore } from \"react\";\n\nimport { deriveConsentAction } from \"./consent-action\";\nimport { recordConsentAction } from \"./consent-actions\";\nimport {\n  CONSENT_COOKIE_MAX_AGE_SECONDS,\n  CONSENT_COOKIE_NAME,\n  DENIED_CATEGORIES,\n  GRANTED_CATEGORIES,\n  parseConsentCookie,\n  serializeConsentCookieValue,\n} from \"./cookie\";\n\n/**\n * Framework-agnostic, cookie-backed consent store. Lives as a single module\n * singleton so `ReploScripts`, the site's consent banner, and `AnalyticsProvider`\n * all share the same state regardless of where they sit in the React tree \u2014 no\n * provider-ancestor relationship is required.\n *\n * Consent-dependent work (script injection, banner visibility) happens on the\n * client (effects / post-mount), so there is no SSR/hydration mismatch. The\n * client reads the (non-httpOnly) consent cookie directly, so no server seed is\n * needed. The whole-site `mode` comes from the `data-replo-consent-mode`\n * attribute on `<html>`.\n */\n\nexport interface ConsentState {\n  mode: ConsentMode;\n  categories: ConsentCategories;\n  /** Epoch ms when the visitor last made a choice, or null if undecided. */\n  decidedAt: number | null;\n  /**\n   * Persistent pseudonymous per-browser id linking a visitor's consent history.\n   * Absent until the first `commit()` (and on legacy pre-id cookies, until the\n   * next interaction lazily backfills it).\n   */\n  consentId?: string;\n}\n\n// The non-necessary categories a visitor can grant or revoke. `necessary` is\n// always granted and never toggled.\nconst TOGGLEABLE_CATEGORIES: Exclude<ConsentCategory, \"necessary\">[] = [\n  \"analytics\",\n  \"marketing\",\n  \"preferences\",\n  \"sale_of_data\",\n];\n\n// A stable reference for SSR / first hydration render. Consent-dependent DOM is\n// only produced on the client, so this constant never causes a mismatch.\nconst SERVER_SNAPSHOT: ConsentState = Object.freeze({\n  mode: \"off\",\n  categories: DENIED_CATEGORIES,\n  decidedAt: null,\n});\n\nconst listeners = new Set<() => void>();\nlet snapshot: ConsentState | null = null;\n\nfunction isConsentMode(value: string | null | undefined): value is ConsentMode {\n  return value === \"off\" || value === \"simple\" || value === \"per-category\";\n}\n\nfunction resolveMode(): ConsentMode {\n  if (typeof window === \"undefined\") {\n    return \"off\";\n  }\n  const attribute = document.documentElement.dataset.reploConsentMode;\n  return isConsentMode(attribute) ? attribute : \"off\";\n}\n\n// Used when the consent caller doesn't declare a policy version via\n// `useConsent({ version })` or the store method options.\nconst DEFAULT_CONSENT_POLICY_VERSION = 1;\n\nfunction computeSnapshot(): ConsentState {\n  if (typeof window === \"undefined\") {\n    return SERVER_SNAPSHOT;\n  }\n\n  const mode = resolveMode();\n\n  const fromCookie = parseConsentCookie(document.cookie);\n  if (fromCookie) {\n    return {\n      mode,\n      categories: {\n        necessary: true,\n        analytics: fromCookie.categories.analytics,\n        marketing: fromCookie.categories.marketing,\n        preferences: fromCookie.categories.preferences,\n        sale_of_data: fromCookie.categories.sale_of_data,\n      },\n      decidedAt: fromCookie.decidedAt,\n      consentId: fromCookie.consentId,\n    };\n  }\n\n  return { mode, categories: DENIED_CATEGORIES, decidedAt: null };\n}\n\nfunction writeCookie(\n  categories: ConsentCategories,\n  decidedAt: number,\n  consentId: string,\n) {\n  if (typeof document === \"undefined\") {\n    return;\n  }\n  const value = serializeConsentCookieValue({\n    categories,\n    decidedAt,\n    consentId,\n  });\n  document.cookie = `${CONSENT_COOKIE_NAME}=${value}; path=/; max-age=${CONSENT_COOKIE_MAX_AGE_SECONDS}; SameSite=Lax`;\n}\n\nfunction notify() {\n  for (const listener of listeners) {\n    listener();\n  }\n}\n\nfunction commit({\n  categories,\n  policyVersion = DEFAULT_CONSENT_POLICY_VERSION,\n}: {\n  categories: ConsentCategories;\n  policyVersion?: number;\n}) {\n  const previous = consentStore.getSnapshot();\n  const decidedAt = Date.now();\n  // Reuse the visitor's existing id, or mint one on the first decision (also\n  // lazily backfills legacy pre-id cookies). `crypto.randomUUID` is available in\n  // every browser we target and on the server (where commit() never runs).\n  const consentId = previous.consentId ?? crypto.randomUUID();\n  const resultingCategories: ConsentCategories = {\n    ...categories,\n    necessary: true,\n  };\n  writeCookie(categories, decidedAt, consentId);\n  snapshot = {\n    mode: previous.mode,\n    categories: resultingCategories,\n    decidedAt,\n    consentId,\n  };\n  notify();\n\n  // Revocation cannot unload an already-loaded vendor. If the visitor had\n  // previously decided and is now turning a granted category off, reload so the\n  // page renders without those scripts. Deferred until after the audit record is\n  // sent so the reload doesn't cancel the in-flight server action.\n  const wasDowngrade =\n    previous.decidedAt !== null &&\n    TOGGLEABLE_CATEGORIES.some((category) => {\n      return previous.categories[category] && !categories[category];\n    });\n  const reloadIfDowngraded = () => {\n    if (wasDowngrade && typeof window !== \"undefined\") {\n      window.location.reload();\n    }\n  };\n\n  // Proof-of-consent audit record (ungated by consent, but only on managed\n  // sites). On `mode === \"off\"` there is no banner/consent UX, so a\n  // `setTrackingConsent()` call from a third-party script would only produce\n  // meaningless `consent_mode: \"off\"` noise \u2014 skip it. Egress runs through a\n  // server action (like the cart) so the client never needs the project id or\n  // analytics-fire URL.\n  if (previous.mode !== \"off\") {\n    void recordConsentAction({\n      consentId,\n      action: deriveConsentAction({ previous, next: resultingCategories }),\n      categories: resultingCategories,\n      consentMode: previous.mode,\n      decidedAt,\n      policyVersion,\n    }).finally(reloadIfDowngraded);\n  } else {\n    reloadIfDowngraded();\n  }\n}\n\nexport const consentStore = {\n  getSnapshot(): ConsentState {\n    if (!snapshot) {\n      snapshot = computeSnapshot();\n    }\n    return snapshot;\n  },\n  getServerSnapshot(): ConsentState {\n    return SERVER_SNAPSHOT;\n  },\n  subscribe(listener: () => void): () => void {\n    listeners.add(listener);\n    return () => {\n      listeners.delete(listener);\n    };\n  },\n  /** Grant every consent category. */\n  accept(options: { policyVersion?: number } = {}) {\n    commit({\n      categories: GRANTED_CATEGORIES,\n      policyVersion: options.policyVersion,\n    });\n  },\n  /** Deny every non-necessary category. */\n  reject(options: { policyVersion?: number } = {}) {\n    commit({\n      categories: DENIED_CATEGORIES,\n      policyVersion: options.policyVersion,\n    });\n  },\n  /** Set a subset of categories, leaving the rest at their current value. */\n  updateCategories({\n    next,\n    policyVersion,\n  }: {\n    next: Partial<ConsentCategories>;\n    policyVersion?: number;\n  }) {\n    const current = consentStore.getSnapshot().categories;\n    commit({\n      categories: { ...current, ...next, necessary: true },\n      policyVersion,\n    });\n  },\n  /** Test-only: reset cached state so the next read recomputes. */\n  reset() {\n    snapshot = null;\n  },\n};\n\nexport interface UseConsentOptions {\n  /**\n   * Site-owned consent policy version, stamped onto each proof-of-consent\n   * record so a decision can be tied to the exact banner the visitor saw.\n   * Bump it whenever the banner copy or category set changes. Defaults to 1.\n   */\n  version?: number;\n}\n\nexport interface UseConsentResult extends ConsentState {\n  accept(): void;\n  reject(): void;\n  updateCategories(next: Partial<ConsentCategories>): void;\n}\n\nexport function useConsent(options: UseConsentOptions = {}): UseConsentResult {\n  const policyVersion = options.version;\n  const state = useSyncExternalStore(\n    consentStore.subscribe,\n    consentStore.getSnapshot,\n    consentStore.getServerSnapshot,\n  );\n  return {\n    ...state,\n    accept: () => consentStore.accept({ policyVersion }),\n    reject: () => consentStore.reject({ policyVersion }),\n    updateCategories: (next) => {\n      consentStore.updateCategories({ next, policyVersion });\n    },\n  };\n}\n\n/**\n * Whether a script requiring `requiredConsent` is allowed to load right now.\n * `mode === \"off\"` always allows; otherwise every required category must be\n * granted. An empty requirement list is always allowed.\n */\nexport function isConsentAllowed({\n  state,\n  requiredConsent,\n}: {\n  state: ConsentState;\n  requiredConsent: ConsentCategory[];\n}): boolean {\n  if (state.mode === \"off\") {\n    return true;\n  }\n  if (requiredConsent.length === 0) {\n    return true;\n  }\n  return requiredConsent.every((category) => state.categories[category]);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/consent/cookie.d.ts

@@ -0,0 +1,36 @@
+import type { ConsentCategory } from "../_vendor/schemas/generated/consent";
+/**
+ * Pure (non-React, framework-agnostic) consent cookie helpers used by the client
+ * store (`consent-store.ts`).
+ */
+export declare const CONSENT_COOKIE_NAME = "replo_consent";
+export declare const CONSENT_COOKIE_VERSION = 1;
+export declare const CONSENT_COOKIE_MAX_AGE_SECONDS: number;
+export type ConsentCategories = Record<ConsentCategory, boolean>;
+/** Persisted cookie payload. `necessary` is always granted and never stored. */
+export interface ConsentCookiePayload {
+    version: number;
+    decidedAt: number;
+    /** Persistent pseudonymous per-browser id; absent on pre-id (legacy) cookies. */
+    consentId?: string;
+    categories: {
+        analytics: boolean;
+        marketing: boolean;
+        preferences: boolean;
+        sale_of_data: boolean;
+    };
+}
+export declare const DENIED_CATEGORIES: ConsentCategories;
+export declare const GRANTED_CATEGORIES: ConsentCategories;
+/**
+ * Parse a raw `document.cookie` (or a single cookie value) into a payload.
+ * Returns null for missing, malformed, or stale-version cookies so callers
+ * treat the visitor as undecided and re-prompt.
+ */
+export declare function parseConsentCookie(rawCookie: string | undefined): ConsentCookiePayload | null;
+/** Serialize categories into the JSON-encoded cookie value (not the full Set-Cookie line). */
+export declare function serializeConsentCookieValue({ categories, decidedAt, consentId, }: {
+    categories: ConsentCategories;
+    decidedAt: number;
+    consentId?: string;
+}): string;

package/consent/cookie.js

@@ -0,0 +1,82 @@
+import { parseJsonOrNull } from "../_vendor/replo-utils/lib/json.mjs";
+import { z } from "zod";
+const CONSENT_COOKIE_NAME = "replo_consent";
+const CONSENT_COOKIE_VERSION = 1;
+const CONSENT_COOKIE_MAX_AGE_SECONDS = 60 * 60 * 24 * 180;
+const persistedCookieSchema = z.object({
+  version: z.literal(CONSENT_COOKIE_VERSION),
+  decidedAt: z.number().optional(),
+  consentId: z.string().optional(),
+  categories: z.object({
+    analytics: z.boolean(),
+    marketing: z.boolean(),
+    preferences: z.boolean(),
+    sale_of_data: z.boolean()
+  })
+});
+const DENIED_CATEGORIES = {
+  necessary: true,
+  analytics: false,
+  marketing: false,
+  preferences: false,
+  sale_of_data: false
+};
+const GRANTED_CATEGORIES = {
+  necessary: true,
+  analytics: true,
+  marketing: true,
+  preferences: true,
+  sale_of_data: true
+};
+function parseConsentCookie(rawCookie) {
+  if (!rawCookie) {
+    return null;
+  }
+  const match = rawCookie.split("; ").find((entry) => entry.startsWith(`${CONSENT_COOKIE_NAME}=`));
+  const encoded = match ? match.slice(CONSENT_COOKIE_NAME.length + 1) : rawCookie;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(encoded);
+  } catch {
+    return null;
+  }
+  const result = persistedCookieSchema.safeParse(parseJsonOrNull(decoded));
+  if (!result.success) {
+    return null;
+  }
+  const { decidedAt, categories, consentId } = result.data;
+  return {
+    version: CONSENT_COOKIE_VERSION,
+    decidedAt: decidedAt ?? Date.now(),
+    consentId,
+    categories
+  };
+}
+function serializeConsentCookieValue({
+  categories,
+  decidedAt,
+  consentId
+}) {
+  const payload = {
+    version: CONSENT_COOKIE_VERSION,
+    decidedAt,
+    consentId,
+    categories: {
+      analytics: categories.analytics,
+      marketing: categories.marketing,
+      preferences: categories.preferences,
+      sale_of_data: categories.sale_of_data
+    }
+  };
+  return encodeURIComponent(JSON.stringify(payload));
+}
+export {
+  CONSENT_COOKIE_MAX_AGE_SECONDS,
+  CONSENT_COOKIE_NAME,
+  CONSENT_COOKIE_VERSION,
+  DENIED_CATEGORIES,
+  GRANTED_CATEGORIES,
+  parseConsentCookie,
+  serializeConsentCookieValue
+};
+//# sourceMappingURL=cookie.js.map

package/consent/cookie.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../consent/cookie.ts"],
+  "sourcesContent": ["import type { ConsentCategory } from \"schemas/generated/consent\";\n\nimport { parseJsonOrNull } from \"replo-utils/lib/json\";\nimport { z } from \"zod\";\n\n/**\n * Pure (non-React, framework-agnostic) consent cookie helpers used by the client\n * store (`consent-store.ts`).\n */\n\nexport const CONSENT_COOKIE_NAME = \"replo_consent\";\nexport const CONSENT_COOKIE_VERSION = 1;\nexport const CONSENT_COOKIE_MAX_AGE_SECONDS = 60 * 60 * 24 * 180; // 180 days\n\n// Validates the untrusted JSON cookie payload at the parse boundary. A stale\n// version (or any shape mismatch) fails `safeParse`, so the caller treats the\n// visitor as undecided and re-prompts.\n//\n// `consentId` is OPTIONAL on purpose: it was added after v1 shipped, and we must\n// NOT bump `CONSENT_COOKIE_VERSION` to introduce it. Bumping would fail this\n// `safeParse` for every existing cookie, re-showing the banner and dropping the\n// visitor's prior decision. Optional keeps v1 cookies valid; `commit()` lazily\n// backfills the id on the next interaction.\nconst persistedCookieSchema = z.object({\n  version: z.literal(CONSENT_COOKIE_VERSION),\n  decidedAt: z.number().optional(),\n  consentId: z.string().optional(),\n  categories: z.object({\n    analytics: z.boolean(),\n    marketing: z.boolean(),\n    preferences: z.boolean(),\n    sale_of_data: z.boolean(),\n  }),\n});\n\nexport type ConsentCategories = Record<ConsentCategory, boolean>;\n\n/** Persisted cookie payload. `necessary` is always granted and never stored. */\nexport interface ConsentCookiePayload {\n  version: number;\n  decidedAt: number;\n  /** Persistent pseudonymous per-browser id; absent on pre-id (legacy) cookies. */\n  consentId?: string;\n  categories: {\n    analytics: boolean;\n    marketing: boolean;\n    preferences: boolean;\n    sale_of_data: boolean;\n  };\n}\n\nexport const DENIED_CATEGORIES: ConsentCategories = {\n  necessary: true,\n  analytics: false,\n  marketing: false,\n  preferences: false,\n  sale_of_data: false,\n};\n\nexport const GRANTED_CATEGORIES: ConsentCategories = {\n  necessary: true,\n  analytics: true,\n  marketing: true,\n  preferences: true,\n  sale_of_data: true,\n};\n\n/**\n * Parse a raw `document.cookie` (or a single cookie value) into a payload.\n * Returns null for missing, malformed, or stale-version cookies so callers\n * treat the visitor as undecided and re-prompt.\n */\nexport function parseConsentCookie(\n  rawCookie: string | undefined,\n): ConsentCookiePayload | null {\n  if (!rawCookie) {\n    return null;\n  }\n  const match = rawCookie\n    .split(\"; \")\n    .find((entry) => entry.startsWith(`${CONSENT_COOKIE_NAME}=`));\n  const encoded = match\n    ? match.slice(CONSENT_COOKIE_NAME.length + 1)\n    : rawCookie;\n\n  // A tampered/corrupted cookie (bad percent-encoding) must not throw \u2014 that\n  // would crash the client snapshot or the server seed read. Treat as undecided.\n  let decoded: string;\n  try {\n    decoded = decodeURIComponent(encoded);\n  } catch {\n    return null;\n  }\n\n  const result = persistedCookieSchema.safeParse(parseJsonOrNull(decoded));\n  if (!result.success) {\n    return null;\n  }\n  const { decidedAt, categories, consentId } = result.data;\n\n  return {\n    version: CONSENT_COOKIE_VERSION,\n    decidedAt: decidedAt ?? Date.now(),\n    consentId,\n    categories,\n  };\n}\n\n/** Serialize categories into the JSON-encoded cookie value (not the full Set-Cookie line). */\nexport function serializeConsentCookieValue({\n  categories,\n  decidedAt,\n  consentId,\n}: {\n  categories: ConsentCategories;\n  decidedAt: number;\n  consentId?: string;\n}): string {\n  const payload: ConsentCookiePayload = {\n    version: CONSENT_COOKIE_VERSION,\n    decidedAt,\n    consentId,\n    categories: {\n      analytics: categories.analytics,\n      marketing: categories.marketing,\n      preferences: categories.preferences,\n      sale_of_data: categories.sale_of_data,\n    },\n  };\n  return encodeURIComponent(JSON.stringify(payload));\n}\n"],
+  "mappings": "AAEA,SAAS,uBAAuB;AAChC,SAAS,SAAS;AAOX,MAAM,sBAAsB;AAC5B,MAAM,yBAAyB;AAC/B,MAAM,iCAAiC,KAAK,KAAK,KAAK;AAW7D,MAAM,wBAAwB,EAAE,OAAO;AAAA,EACrC,SAAS,EAAE,QAAQ,sBAAsB;AAAA,EACzC,WAAW,EAAE,OAAO,EAAE,SAAS;AAAA,EAC/B,WAAW,EAAE,OAAO,EAAE,SAAS;AAAA,EAC/B,YAAY,EAAE,OAAO;AAAA,IACnB,WAAW,EAAE,QAAQ;AAAA,IACrB,WAAW,EAAE,QAAQ;AAAA,IACrB,aAAa,EAAE,QAAQ;AAAA,IACvB,cAAc,EAAE,QAAQ;AAAA,EAC1B,CAAC;AACH,CAAC;AAkBM,MAAM,oBAAuC;AAAA,EAClD,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AAAA,EACX,aAAa;AAAA,EACb,cAAc;AAChB;AAEO,MAAM,qBAAwC;AAAA,EACnD,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AAAA,EACX,aAAa;AAAA,EACb,cAAc;AAChB;AAOO,SAAS,mBACd,WAC6B;AAC7B,MAAI,CAAC,WAAW;AACd,WAAO;AAAA,EACT;AACA,QAAM,QAAQ,UACX,MAAM,IAAI,EACV,KAAK,CAAC,UAAU,MAAM,WAAW,GAAG,mBAAmB,GAAG,CAAC;AAC9D,QAAM,UAAU,QACZ,MAAM,MAAM,oBAAoB,SAAS,CAAC,IAC1C;AAIJ,MAAI;AACJ,MAAI;AACF,cAAU,mBAAmB,OAAO;AAAA,EACtC,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,sBAAsB,UAAU,gBAAgB,OAAO,CAAC;AACvE,MAAI,CAAC,OAAO,SAAS;AACnB,WAAO;AAAA,EACT;AACA,QAAM,EAAE,WAAW,YAAY,UAAU,IAAI,OAAO;AAEpD,SAAO;AAAA,IACL,SAAS;AAAA,IACT,WAAW,aAAa,KAAK,IAAI;AAAA,IACjC;AAAA,IACA;AAAA,EACF;AACF;AAGO,SAAS,4BAA4B;AAAA,EAC1C;AAAA,EACA;AAAA,EACA;AACF,GAIW;AACT,QAAM,UAAgC;AAAA,IACpC,SAAS;AAAA,IACT;AAAA,IACA;AAAA,IACA,YAAY;AAAA,MACV,WAAW,WAAW;AAAA,MACtB,WAAW,WAAW;AAAA,MACtB,aAAa,WAAW;AAAA,MACxB,cAAc,WAAW;AAAA,IAC3B;AAAA,EACF;AACA,SAAO,mBAAmB,KAAK,UAAU,OAAO,CAAC;AACnD;",
+  "names": []
+}

package/consent/replo-scripts.d.ts

@@ -0,0 +1,23 @@
+import type { ReploScriptEntry, ScriptTagDescriptor } from "../_vendor/schemas/generated/consent";
+/**
+ * Injects the resolved tags into `document.head` once a caller has decided
+ * consent allows it. Reused both for author-managed `ReploScripts` entries and
+ * for the implicit Replo first-party pixel.
+ *
+ * DOM insertion (not JSX) is required because inline `<script>` bodies set via
+ * React's `dangerouslySetInnerHTML` never execute. Each node is tagged with
+ * `data-replo-script-id` (plus a per-tag index) so re-renders and React Strict
+ * Mode double-invokes do not double-inject.
+ */
+export declare function InjectedScript({ baseId, descriptors, }: {
+    baseId: string;
+    descriptors: ScriptTagDescriptor[];
+}): null;
+/**
+ * The single registry component for all managed tracking scripts on the site.
+ * Authored once in `app/layout.tsx`; the agent/miniapp only edit the `scripts`
+ * array. Each entry registers itself and is gated + injected per consent.
+ */
+export declare function ReploScripts({ scripts }: {
+    scripts: ReploScriptEntry[];
+}): import("react/jsx-runtime").JSX.Element;

package/consent/replo-scripts.js

@@ -0,0 +1,102 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { useEffect } from "react";
+import { isConsentAllowed, useConsent } from "./consent-store";
+import { registerScript, unregisterScript } from "./script-registration-store";
+import { buildScriptTags, defaultConsentFor } from "./script-snippets";
+import { installConsentWindowApi } from "./window-api";
+function scriptId(entry) {
+  if (entry.type === "custom") {
+    return `custom:${entry.id}`;
+  }
+  if (entry.type === "snippet") {
+    return `snippet:${entry.id}`;
+  }
+  return `${entry.type}:${entry.identifier}`;
+}
+function requiredConsentFor(entry) {
+  if (entry.type === "custom" || entry.type === "snippet") {
+    return entry.requiredConsent;
+  }
+  return entry.requiredConsent ?? defaultConsentFor(entry.type);
+}
+function descriptorsFor(entry) {
+  if (entry.type === "custom") {
+    if (entry.src) {
+      return [{ kind: "external", src: entry.src }];
+    }
+    if (entry.body) {
+      return [{ kind: "inline", body: entry.body }];
+    }
+    return [];
+  }
+  if (entry.type === "snippet") {
+    return [{ kind: "inline", body: entry.body }];
+  }
+  return buildScriptTags({ type: entry.type, identifier: entry.identifier });
+}
+function InjectedScript({
+  baseId,
+  descriptors
+}) {
+  const injectionKey = `${baseId}|${JSON.stringify(descriptors)}`;
+  useEffect(() => {
+    if (typeof document === "undefined") {
+      return;
+    }
+    const createdNodes = [];
+    descriptors.forEach((descriptor, index) => {
+      const nodeId = `${baseId}#${index}`;
+      const existing = document.querySelector(
+        `script[data-replo-script-id="${nodeId}"]`
+      );
+      if (existing) {
+        return;
+      }
+      const scriptElement = document.createElement("script");
+      scriptElement.dataset.reploScriptId = nodeId;
+      if (descriptor.kind === "external") {
+        scriptElement.src = descriptor.src;
+        scriptElement.async = true;
+        for (const [attributeName, attributeValue] of Object.entries(
+          descriptor.attributes ?? {}
+        )) {
+          scriptElement.setAttribute(attributeName, attributeValue);
+        }
+      } else {
+        scriptElement.textContent = descriptor.body;
+      }
+      document.head.append(scriptElement);
+      createdNodes.push(scriptElement);
+    });
+    return () => {
+      for (const node of createdNodes) {
+        node.remove();
+      }
+    };
+  }, [injectionKey]);
+  return null;
+}
+function ManagedScript({ entry }) {
+  const consent = useConsent();
+  const requiredConsent = requiredConsentFor(entry);
+  const id = scriptId(entry);
+  const consentKey = requiredConsent.join(",");
+  useEffect(() => {
+    registerScript({ id, type: entry.type, requiredConsent });
+    return () => unregisterScript(id);
+  }, [id, entry.type, consentKey]);
+  if (!isConsentAllowed({ state: consent, requiredConsent })) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(InjectedScript, { baseId: id, descriptors: descriptorsFor(entry) });
+}
+function ReploScripts({ scripts }) {
+  useEffect(() => installConsentWindowApi(), []);
+  return /* @__PURE__ */ jsx(Fragment, { children: scripts.map((entry) => /* @__PURE__ */ jsx(ManagedScript, { entry }, scriptId(entry))) });
+}
+export {
+  InjectedScript,
+  ReploScripts
+};
+//# sourceMappingURL=replo-scripts.js.map

package/consent/replo-scripts.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../consent/replo-scripts.tsx"],
+  "sourcesContent": ["\"use client\";\n\nimport type {\n  ConsentCategory,\n  ReploScriptEntry,\n  ScriptTagDescriptor,\n} from \"schemas/generated/consent\";\n\nimport { useEffect } from \"react\";\n\nimport { isConsentAllowed, useConsent } from \"./consent-store\";\nimport { registerScript, unregisterScript } from \"./script-registration-store\";\nimport { buildScriptTags, defaultConsentFor } from \"./script-snippets\";\nimport { installConsentWindowApi } from \"./window-api\";\n\n/**\n * Stable identity for an entry, used as React key and DOM dedupe key. `snippet`\n * and `custom` entries key on their `id`; identifier providers on type+id.\n */\nfunction scriptId(entry: ReploScriptEntry): string {\n  if (entry.type === \"custom\") {\n    return `custom:${entry.id}`;\n  }\n  if (entry.type === \"snippet\") {\n    return `snippet:${entry.id}`;\n  }\n  return `${entry.type}:${entry.identifier}`;\n}\n\nfunction requiredConsentFor(entry: ReploScriptEntry): ConsentCategory[] {\n  if (entry.type === \"custom\" || entry.type === \"snippet\") {\n    return entry.requiredConsent;\n  }\n  return entry.requiredConsent ?? defaultConsentFor(entry.type);\n}\n\n/**\n * Resolves an entry to the concrete tags to inject. An identifier provider may\n * resolve to multiple tags (GA4 = external loader + inline config); a `snippet`\n * entry injects its pasted body inline; a `custom` entry is a single external\n * `src` or inline `body`.\n */\nfunction descriptorsFor(entry: ReploScriptEntry): ScriptTagDescriptor[] {\n  if (entry.type === \"custom\") {\n    if (entry.src) {\n      return [{ kind: \"external\", src: entry.src }];\n    }\n    if (entry.body) {\n      return [{ kind: \"inline\", body: entry.body }];\n    }\n    return [];\n  }\n  if (entry.type === \"snippet\") {\n    return [{ kind: \"inline\", body: entry.body }];\n  }\n  return buildScriptTags({ type: entry.type, identifier: entry.identifier });\n}\n\n/**\n * Injects the resolved tags into `document.head` once a caller has decided\n * consent allows it. Reused both for author-managed `ReploScripts` entries and\n * for the implicit Replo first-party pixel.\n *\n * DOM insertion (not JSX) is required because inline `<script>` bodies set via\n * React's `dangerouslySetInnerHTML` never execute. Each node is tagged with\n * `data-replo-script-id` (plus a per-tag index) so re-renders and React Strict\n * Mode double-invokes do not double-inject.\n */\nexport function InjectedScript({\n  baseId,\n  descriptors,\n}: {\n  baseId: string;\n  descriptors: ScriptTagDescriptor[];\n}) {\n  // Re-inject only when the resolved tags actually change.\n  const injectionKey = `${baseId}|${JSON.stringify(descriptors)}`;\n\n  // eslint-disable-next-line replo/no-use-effect -- script injection is a DOM side effect that must run after mount and on consent changes\n  useEffect(() => {\n    if (typeof document === \"undefined\") {\n      return;\n    }\n    const createdNodes: HTMLScriptElement[] = [];\n    descriptors.forEach((descriptor, index) => {\n      const nodeId = `${baseId}#${index}`;\n      const existing = document.querySelector(\n        `script[data-replo-script-id=\"${nodeId}\"]`,\n      );\n      if (existing) {\n        return;\n      }\n      const scriptElement = document.createElement(\"script\");\n      scriptElement.dataset.reploScriptId = nodeId;\n      if (descriptor.kind === \"external\") {\n        scriptElement.src = descriptor.src;\n        scriptElement.async = true;\n        for (const [attributeName, attributeValue] of Object.entries(\n          descriptor.attributes ?? {},\n        )) {\n          scriptElement.setAttribute(attributeName, attributeValue);\n        }\n      } else {\n        scriptElement.textContent = descriptor.body;\n      }\n      document.head.append(scriptElement);\n      createdNodes.push(scriptElement);\n    });\n\n    return () => {\n      // Removing the node does not unload an already-loaded vendor (see the plan's\n      // revocation note); full teardown is a reload triggered by the banner. This\n      // cleanup keeps the DOM tidy and prevents duplicates across remounts.\n      for (const node of createdNodes) {\n        node.remove();\n      }\n    };\n  }, [injectionKey]);\n\n  return null;\n}\n\nfunction ManagedScript({ entry }: { entry: ReploScriptEntry }) {\n  const consent = useConsent();\n  const requiredConsent = requiredConsentFor(entry);\n  const id = scriptId(entry);\n  const consentKey = requiredConsent.join(\",\");\n\n  // eslint-disable-next-line replo/no-use-effect -- register/unregister with the singleton so the analytics provider can gate sinks by what's on the page\n  useEffect(() => {\n    registerScript({ id, type: entry.type, requiredConsent });\n    return () => unregisterScript(id);\n  }, [id, entry.type, consentKey]);\n\n  if (!isConsentAllowed({ state: consent, requiredConsent })) {\n    return null;\n  }\n  return <InjectedScript baseId={id} descriptors={descriptorsFor(entry)} />;\n}\n\n/**\n * The single registry component for all managed tracking scripts on the site.\n * Authored once in `app/layout.tsx`; the agent/miniapp only edit the `scripts`\n * array. Each entry registers itself and is gated + injected per consent.\n */\nexport function ReploScripts({ scripts }: { scripts: ReploScriptEntry[] }) {\n  // eslint-disable-next-line replo/no-use-effect -- install the window.Replo.customerPrivacy API + change event once the consent runtime mounts\n  useEffect(() => installConsentWindowApi(), []);\n\n  return (\n    <>\n      {scripts.map((entry) => (\n        <ManagedScript key={scriptId(entry)} entry={entry} />\n      ))}\n    </>\n  );\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/consent/script-registration-store.d.ts

@@ -0,0 +1,25 @@
+import type { ConsentCategory, ReploScriptType } from "../_vendor/schemas/generated/consent";
+/**
+ * Tracks which managed scripts are currently mounted on the page. Each
+ * `ReploScripts` entry registers itself here on mount, so the analytics provider
+ * can create sinks only for providers that are actually present (and consented),
+ * without importing a static list. Like the consent store, this is a singleton
+ * rather than React context so it works regardless of tree position.
+ */
+export interface RegisteredScript {
+    id: string;
+    type: ReploScriptType;
+    requiredConsent: ConsentCategory[];
+}
+export declare const scriptRegistrationStore: {
+    register(script: RegisteredScript): void;
+    unregister(id: string): void;
+    getSnapshot(): RegisteredScript[];
+    getServerSnapshot(): RegisteredScript[];
+    subscribe(listener: () => void): () => void;
+    /** Test-only: clear the registry between cases. */
+    reset(): void;
+};
+export declare function registerScript(script: RegisteredScript): void;
+export declare function unregisterScript(id: string): void;
+export declare function useRegisteredScripts(): RegisteredScript[];

package/consent/script-registration-store.js

@@ -0,0 +1,61 @@
+"use client";
+import { useSyncExternalStore } from "react";
+const registry = /* @__PURE__ */ new Map();
+const listeners = /* @__PURE__ */ new Set();
+let snapshot = [];
+const SERVER_SNAPSHOT = [];
+function emit() {
+  snapshot = [...registry.values()];
+  for (const listener of listeners) {
+    listener();
+  }
+}
+const scriptRegistrationStore = {
+  register(script) {
+    registry.set(script.id, script);
+    emit();
+  },
+  unregister(id) {
+    if (registry.delete(id)) {
+      emit();
+    }
+  },
+  getSnapshot() {
+    return snapshot;
+  },
+  getServerSnapshot() {
+    return SERVER_SNAPSHOT;
+  },
+  subscribe(listener) {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  },
+  /** Test-only: clear the registry between cases. */
+  reset() {
+    registry.clear();
+    listeners.clear();
+    snapshot = [];
+  }
+};
+function registerScript(script) {
+  scriptRegistrationStore.register(script);
+}
+function unregisterScript(id) {
+  scriptRegistrationStore.unregister(id);
+}
+function useRegisteredScripts() {
+  return useSyncExternalStore(
+    scriptRegistrationStore.subscribe,
+    scriptRegistrationStore.getSnapshot,
+    scriptRegistrationStore.getServerSnapshot
+  );
+}
+export {
+  registerScript,
+  scriptRegistrationStore,
+  unregisterScript,
+  useRegisteredScripts
+};
+//# sourceMappingURL=script-registration-store.js.map

package/consent/script-registration-store.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../consent/script-registration-store.ts"],
+  "sourcesContent": ["\"use client\";\n\nimport type {\n  ConsentCategory,\n  ReploScriptType,\n} from \"schemas/generated/consent\";\n\nimport { useSyncExternalStore } from \"react\";\n\n/**\n * Tracks which managed scripts are currently mounted on the page. Each\n * `ReploScripts` entry registers itself here on mount, so the analytics provider\n * can create sinks only for providers that are actually present (and consented),\n * without importing a static list. Like the consent store, this is a singleton\n * rather than React context so it works regardless of tree position.\n */\n\nexport interface RegisteredScript {\n  id: string;\n  type: ReploScriptType;\n  requiredConsent: ConsentCategory[];\n}\n\nconst registry = new Map<string, RegisteredScript>();\nconst listeners = new Set<() => void>();\n\n// useSyncExternalStore requires a referentially-stable snapshot between emits.\nlet snapshot: RegisteredScript[] = [];\n\nconst SERVER_SNAPSHOT: RegisteredScript[] = [];\n\nfunction emit() {\n  snapshot = [...registry.values()];\n  for (const listener of listeners) {\n    listener();\n  }\n}\n\nexport const scriptRegistrationStore = {\n  register(script: RegisteredScript) {\n    registry.set(script.id, script);\n    emit();\n  },\n  unregister(id: string) {\n    if (registry.delete(id)) {\n      emit();\n    }\n  },\n  getSnapshot(): RegisteredScript[] {\n    return snapshot;\n  },\n  getServerSnapshot(): RegisteredScript[] {\n    return SERVER_SNAPSHOT;\n  },\n  subscribe(listener: () => void): () => void {\n    listeners.add(listener);\n    return () => {\n      listeners.delete(listener);\n    };\n  },\n  /** Test-only: clear the registry between cases. */\n  reset() {\n    registry.clear();\n    listeners.clear();\n    snapshot = [];\n  },\n};\n\nexport function registerScript(script: RegisteredScript) {\n  scriptRegistrationStore.register(script);\n}\n\nexport function unregisterScript(id: string) {\n  scriptRegistrationStore.unregister(id);\n}\n\nexport function useRegisteredScripts(): RegisteredScript[] {\n  return useSyncExternalStore(\n    scriptRegistrationStore.subscribe,\n    scriptRegistrationStore.getSnapshot,\n    scriptRegistrationStore.getServerSnapshot,\n  );\n}\n"],
+  "mappings": ";AAOA,SAAS,4BAA4B;AAgBrC,MAAM,WAAW,oBAAI,IAA8B;AACnD,MAAM,YAAY,oBAAI,IAAgB;AAGtC,IAAI,WAA+B,CAAC;AAEpC,MAAM,kBAAsC,CAAC;AAE7C,SAAS,OAAO;AACd,aAAW,CAAC,GAAG,SAAS,OAAO,CAAC;AAChC,aAAW,YAAY,WAAW;AAChC,aAAS;AAAA,EACX;AACF;AAEO,MAAM,0BAA0B;AAAA,EACrC,SAAS,QAA0B;AACjC,aAAS,IAAI,OAAO,IAAI,MAAM;AAC9B,SAAK;AAAA,EACP;AAAA,EACA,WAAW,IAAY;AACrB,QAAI,SAAS,OAAO,EAAE,GAAG;AACvB,WAAK;AAAA,IACP;AAAA,EACF;AAAA,EACA,cAAkC;AAChC,WAAO;AAAA,EACT;AAAA,EACA,oBAAwC;AACtC,WAAO;AAAA,EACT;AAAA,EACA,UAAU,UAAkC;AAC1C,cAAU,IAAI,QAAQ;AACtB,WAAO,MAAM;AACX,gBAAU,OAAO,QAAQ;AAAA,IAC3B;AAAA,EACF;AAAA;AAAA,EAEA,QAAQ;AACN,aAAS,MAAM;AACf,cAAU,MAAM;AAChB,eAAW,CAAC;AAAA,EACd;AACF;AAEO,SAAS,eAAe,QAA0B;AACvD,0BAAwB,SAAS,MAAM;AACzC;AAEO,SAAS,iBAAiB,IAAY;AAC3C,0BAAwB,WAAW,EAAE;AACvC;AAEO,SAAS,uBAA2C;AACzD,SAAO;AAAA,IACL,wBAAwB;AAAA,IACxB,wBAAwB;AAAA,IACxB,wBAAwB;AAAA,EAC1B;AACF;",
+  "names": []
+}

package/consent/script-snippets.d.ts

@@ -0,0 +1,24 @@
+import type { ConsentCategory, ReploScriptType, ScriptTagDescriptor } from "../_vendor/schemas/generated/consent";
+type ProviderType = Exclude<ReploScriptType, "custom" | "snippet">;
+/**
+ * Snippet providers don't synthesize tags (the user pastes the provider-issued
+ * snippet as the entry's `body`), but they still get a first-class default
+ * consent categorization like identifier providers.
+ */
+/**
+ * Returns the structured tag descriptors for a named provider. A single provider
+ * can produce multiple tags (e.g. GA4 = external loader + inline config), which
+ * the runtime injects in order.
+ */
+export declare function buildScriptTags({ type, identifier, }: {
+    type: ProviderType;
+    identifier: string;
+}): ScriptTagDescriptor[];
+/**
+ * The default consent categories that gate an identifier-provider script when an
+ * entry does not specify `requiredConsent`. `snippet` and `custom` entries carry
+ * `requiredConsent` explicitly (the runtime has no default for them), so this is
+ * only consulted for identifier providers. Overridable per entry by the customer.
+ */
+export declare function defaultConsentFor(type: ProviderType): ConsentCategory[];
+export {};