@drip-apex/sdk 0.1.0 → 0.3.0

package/src/page-trigger.test.ts

@@ -1,17 +1,21 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { __test } from "./index";
 import { clearRuntimeSignal, getSignals } from "./signals";
-import type { PageTargetingRule } from "./types";
+import type { PageTargetingRule, SegmentCondition } from "./types";
 
 const signal = "page.trigger.pdp_overlay";
+const segmentSignal = "custom.callback.ready";
 
-function installTrigger(triggerJs: string) {
+function installTrigger(
+  triggerJs: string,
+  mode: "manual-callback" | "manual-api" = "manual-callback",
+) {
   const onChange = vi.fn();
   const cleanup = __test.installPageTriggerRule({
     id: "page_1",
     includeRules: [{ type: "simple", pattern: "/products/*", include: true }],
     trigger: {
-      mode: "manual-callback",
+      mode,
       apiName: "pdp_overlay",
       signal,
       triggerJs,
@@ -20,26 +24,232 @@ function installTrigger(triggerJs: string) {
   return { cleanup, onChange };
 }
 
+function installSegmentTrigger(triggerJs: string) {
+  const onChange = vi.fn();
+  const cleanup = __test.installActivateJsTrigger({
+    signal: segmentSignal,
+    operator: "equals",
+    value: true,
+    js: {
+      mode: "activate",
+      code: triggerJs,
+    },
+  } satisfies SegmentCondition, onChange);
+  return { cleanup, onChange };
+}
+
+function installRerunEnvironment() {
+  class FakeElement {
+    getAttribute() { return ""; }
+    closest() { return null; }
+  }
+
+  let mutationCallback: MutationCallback | null = null;
+  const disconnect = vi.fn();
+  const location = { href: "https://shop.test/products/example" };
+  vi.stubGlobal("Element", FakeElement);
+  vi.stubGlobal("location", location);
+  vi.stubGlobal("document", { documentElement: new FakeElement() });
+  vi.stubGlobal("window", {
+    clearInterval,
+    clearTimeout,
+    location,
+    setInterval,
+    setTimeout,
+  });
+  vi.stubGlobal("MutationObserver", class MutationObserver {
+    constructor(callback: MutationCallback) {
+      mutationCallback = callback;
+    }
+
+    observe = vi.fn();
+    disconnect = disconnect;
+    takeRecords = vi.fn(() => []);
+  });
+
+  return {
+    disconnect,
+    mutate() {
+      mutationCallback?.([
+        {
+          target: (globalThis as any).document.documentElement,
+          type: "attributes",
+        } as MutationRecord,
+      ], {} as MutationObserver);
+    },
+  };
+}
+
 describe("Page trigger JS", () => {
   afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
     clearRuntimeSignal(signal);
+    clearRuntimeSignal(segmentSignal);
     clearRuntimeSignal("page.trigger.segment_123_pdp_overlay");
     vi.unstubAllGlobals();
   });
 
-  it("supports activate(), activate(true), and activate(false)", () => {
-    let trigger = installTrigger("activate();");
+  it("re-runs an inactive manual callback after a DOM change and stops after activation", async () => {
+    vi.useFakeTimers();
+    const environment = installRerunEnvironment();
+    (globalThis as any).window.__eligible = false;
+    (globalThis as any).window.__attempts = 0;
+    const trigger = installTrigger(`
+      window.__attempts += 1;
+      if (window.__eligible) activate();
+    `);
+
+    expect((globalThis as any).window.__attempts).toBe(1);
+    expect(getSignals()[signal]).toBeUndefined();
+
+    (globalThis as any).window.__eligible = true;
+    environment.mutate();
+    await vi.advanceTimersByTimeAsync(250);
+
+    expect((globalThis as any).window.__attempts).toBe(2);
     expect(getSignals()[signal]).toBe(true);
     expect(trigger.onChange).toHaveBeenCalledTimes(1);
+    expect(environment.disconnect).toHaveBeenCalledTimes(1);
+
+    environment.mutate();
+    await vi.advanceTimersByTimeAsync(2_000);
+    expect((globalThis as any).window.__attempts).toBe(2);
     trigger.cleanup();
+  });
+
+  it("does not schedule re-runs when the initial callback activates", () => {
+    vi.useFakeTimers();
+    installRerunEnvironment();
+    const setIntervalSpy = vi.spyOn(globalThis, "setInterval");
+    const trigger = installTrigger("activate();");
 
-    trigger = installTrigger("activate(true);");
     expect(getSignals()[signal]).toBe(true);
-    expect(trigger.onChange).toHaveBeenCalledTimes(1);
+    expect(setIntervalSpy).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+    trigger.cleanup();
+  });
+
+  it("stops pending re-runs when the trigger lifecycle is cleaned up", async () => {
+    vi.useFakeTimers();
+    const environment = installRerunEnvironment();
+    (globalThis as any).window.__attempts = 0;
+    const trigger = installTrigger("window.__attempts += 1;");
+
+    expect((globalThis as any).window.__attempts).toBe(1);
+    expect(vi.getTimerCount()).toBe(2);
+    trigger.cleanup();
+
+    expect(environment.disconnect).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(0);
+    await vi.advanceTimersByTimeAsync(10_000);
+    expect((globalThis as any).window.__attempts).toBe(1);
+  });
+
+  it("keeps legacy manual-api trigger JS one-shot", async () => {
+    vi.useFakeTimers();
+    installRerunEnvironment();
+    (globalThis as any).window.__attempts = 0;
+    const trigger = installTrigger("window.__attempts += 1;", "manual-api");
+
+    await vi.advanceTimersByTimeAsync(10_000);
+    expect((globalThis as any).window.__attempts).toBe(1);
+    expect(vi.getTimerCount()).toBe(0);
     trigger.cleanup();
+  });
+
+  it("stops a never-eligible callback after ten bounded re-runs", async () => {
+    vi.useFakeTimers();
+    const environment = installRerunEnvironment();
+    (globalThis as any).window.__attempts = 0;
+    const trigger = installTrigger("window.__attempts += 1;");
+
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+      environment.mutate();
+      await vi.advanceTimersByTimeAsync(250);
+    }
+
+    expect((globalThis as any).window.__attempts).toBe(11);
+    expect(environment.disconnect).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(0);
+
+    environment.mutate();
+    await vi.advanceTimersByTimeAsync(10_000);
+    expect((globalThis as any).window.__attempts).toBe(11);
+    trigger.cleanup();
+  });
+
+  it("counts throwing callbacks toward the re-run bound without an unhandled rejection", async () => {
+    vi.useFakeTimers();
+    const environment = installRerunEnvironment();
+    (globalThis as any).window.__attempts = 0;
+    const trigger = installTrigger(`
+      window.__attempts += 1;
+      throw new Error("not ready");
+    `);
+
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+      environment.mutate();
+      await vi.advanceTimersByTimeAsync(250);
+    }
 
-    trigger = installTrigger("activate(false);");
+    expect((globalThis as any).window.__attempts).toBe(11);
+    expect(environment.disconnect).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(0);
+    trigger.cleanup();
+  });
+
+  it("continues bounded retries when a re-run throws without activating", async () => {
+    vi.useFakeTimers();
+    const environment = installRerunEnvironment();
+    (globalThis as any).window.__attempts = 0;
+    const trigger = installTrigger(`
+      window.__attempts += 1;
+      if (window.__attempts > 1) throw new Error("still not ready");
+    `);
+
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+      environment.mutate();
+      await vi.advanceTimersByTimeAsync(250);
+    }
+
+    expect((globalThis as any).window.__attempts).toBe(11);
     expect(getSignals()[signal]).toBe(false);
+    expect(environment.disconnect).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(0);
+    trigger.cleanup();
+  });
+
+  it.each([
+    ["no argument", "activate();", true],
+    ["true", "activate(true);", true],
+    ["one", "activate(1);", true],
+    ["non-empty string", 'activate("yes");', true],
+    ["false", "activate(false);", false],
+    ["zero", "activate(0);", false],
+    ["empty string", 'activate("");', false],
+    ["null", "activate(null);", false],
+    ["explicit undefined", "activate(undefined);", false],
+  ])("treats %s with documented truthy callback semantics", (_label, code, expected) => {
+    const trigger = installTrigger(code);
+    expect(getSignals()[signal]).toBe(expected);
+    expect(trigger.onChange).toHaveBeenCalledTimes(1);
+    trigger.cleanup();
+  });
+
+  it.each([
+    ["no argument", "activate();", true],
+    ["true", "activate(true);", true],
+    ["one", "activate(1);", true],
+    ["non-empty string", 'activate("yes");', true],
+    ["false", "activate(false);", false],
+    ["zero", "activate(0);", false],
+    ["empty string", 'activate("");', false],
+    ["null", "activate(null);", false],
+    ["explicit undefined", "activate(undefined);", false],
+  ])("uses the same %s semantics for segment callbacks", (_label, code, expected) => {
+    const trigger = installSegmentTrigger(code);
+    expect(getSignals()[segmentSignal]).toBe(expected);
     expect(trigger.onChange).toHaveBeenCalledTimes(1);
     trigger.cleanup();
   });

package/src/performance.ts

@@ -0,0 +1,10 @@
+export function roundPerformance(value: number, precision = 1): number {
+  const factor = 10 ** precision;
+  return Math.round(value * factor) / factor;
+}
+
+export function navigationEntry(): PerformanceNavigationTiming | undefined {
+  return performance.getEntriesByType?.("navigation")?.[0] as
+    | PerformanceNavigationTiming
+    | undefined;
+}

package/src/persistence-decoders.ts

@@ -0,0 +1,18 @@
+import { decodeCompactStore } from "./compact-store";
+
+export type PersistedAssignmentRecord = { variationId: string; epoch: number; assignedAt: number };
+export type PersistedGroupSelection = { experimentId: string; epoch: number };
+export type CompactGroupSelections = Record<string, [string, number]>;
+
+export function decodePersistedAssignments(local: string | null, cookie: string | null): Record<string, PersistedAssignmentRecord> {
+  const compact = { ...decodeCompactStore(cookie, 3), ...decodeCompactStore(local, 3) };
+  const out: Record<string, PersistedAssignmentRecord> = {};
+  for (const [id, value] of Object.entries(compact)) out[id] = {
+    variationId: value[0] as string, epoch: value[1] as number, assignedAt: value[2] as number,
+  };
+  return out;
+}
+
+export function decodePersistedGroupSelections(local: string | null, cookie: string | null): CompactGroupSelections {
+  return { ...decodeCompactStore(local, 2), ...decodeCompactStore(cookie, 2) } as CompactGroupSelections;
+}