@aranova/tracking-next 0.27.0 → 1.0.0

package/dist/client.mjs

@@ -580,10 +580,10 @@ function readStoredRecord() {
     return null;
   }
 }
-function writeRecord(record) {
-  memoryRecord = record;
+function writeRecord(record3) {
+  memoryRecord = record3;
   try {
-    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record));
+    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record3));
   } catch {
   }
 }
@@ -605,9 +605,9 @@ function getOrCaptureLandingParams(sessionId, url) {
   if (memoryRecord && memoryRecord.session_id === sessionId) {
     return memoryRecord.params;
   }
-  const record = { session_id: sessionId, params: captureFromUrl(url) };
-  writeRecord(record);
-  return record.params;
+  const record3 = { session_id: sessionId, params: captureFromUrl(url) };
+  writeRecord(record3);
+  return record3.params;
 }
 function buildLandingPayloadFields(sessionId, override) {
   const params = override ?? (typeof window === "undefined" ? null : getOrCaptureLandingParams(sessionId));
@@ -1439,25 +1439,32 @@ function getOrRotateSessionId(now = Date.now()) {
   return { id: fresh.id, isNew: true };
 }
 
+// ../tracking-core/src/page-view.ts
+import { parse } from "zod/mini";
+
 // ../tracking-core/src/events/page-view.ts
-import { z } from "zod";
-var pageViewMetadataSchema = z.object({
-  page: z.object({
-    title: z.string().nullable(),
+import * as z from "zod/mini";
+var pageViewMetadataSchema = z.strictObject({
+  page: z.strictObject({
+    title: z.nullable(z.string()),
     path: z.string(),
     search: z.string(),
     hash: z.string()
-  }).strict(),
-  referrer: z.string().nullable(),
-  // `.nullable().optional()` — absent (undefined) OR explicit null OR a
+  }),
+  referrer: z.nullable(z.string()),
+  // Optional + nullable — absent (undefined) OR explicit null OR a
   // real viewport object. Mirrors Pydantic's `_Viewport | None = None`
   // on the backend side so the drift test stays clean.
-  viewport: z.object({
-    w: z.number(),
-    h: z.number()
-  }).strict().nullable().optional()
-}).strict();
-var pageViewConfigSchema = z.object({}).strict();
+  viewport: z.optional(
+    z.nullable(
+      z.strictObject({
+        w: z.number(),
+        h: z.number()
+      })
+    )
+  )
+});
+var pageViewConfigSchema = z.strictObject({});
 
 // ../tracking-core/src/page-view.ts
 var LAST_FIRED_URL_STORAGE_KEY = "aranova_tracking_last_fired_url";
@@ -1493,7 +1500,7 @@ function setLastFiredUrl(url) {
 }
 function buildPageViewMetadata(referrerOverride) {
   if (typeof window === "undefined" || typeof document === "undefined") return null;
-  return pageViewMetadataSchema.parse({
+  return parse(pageViewMetadataSchema, {
     page: {
       title: document.title || null,
       path: window.location.pathname,
@@ -1951,186 +1958,198 @@ function createTrackingClient(config) {
   };
 }
 
+// ../tracking-core/src/ingest-typed.ts
+import { parse as parse2 } from "zod/mini";
+
 // ../tracking-core/src/events/cta-click.ts
-import { z as z2 } from "zod";
-var ctaClickMetadataSchema = z2.object({
+import * as z2 from "zod/mini";
+var ctaClickMetadataSchema = z2.strictObject({
   cta_name: z2.string(),
-  page: z2.object({
+  page: z2.strictObject({
     path: z2.string()
-  }).strict(),
-  section: z2.string().nullable().optional(),
-  destination_url: z2.string().nullable().optional(),
+  }),
+  section: z2.optional(z2.nullable(z2.string())),
+  destination_url: z2.optional(z2.nullable(z2.string())),
   // Set by auto-capture (and available to manual callers): the link target
   // and a short element descriptor (tag#id) for tying clicks to specific UI.
-  href: z2.string().nullable().optional(),
-  element: z2.string().nullable().optional()
-}).strict();
-var ctaClickConfigSchema = z2.object({
-  autoCapture: z2.object({
-    selector: z2.string().optional()
-  }).strict().optional()
-}).strict();
+  href: z2.optional(z2.nullable(z2.string())),
+  element: z2.optional(z2.nullable(z2.string()))
+});
+var ctaClickConfigSchema = z2.strictObject({
+  autoCapture: z2.optional(
+    z2.strictObject({
+      selector: z2.optional(z2.string())
+    })
+  )
+});
 
 // ../tracking-core/src/events/sdk-heartbeat.ts
-import { z as z3 } from "zod";
-var sdkHeartbeatTriggersSchema = z3.object({
+import * as z3 from "zod/mini";
+var sdkHeartbeatTriggersSchema = z3.strictObject({
   automatic: z3.array(z3.string()),
   manual: z3.array(z3.string())
-}).strict();
-var sdkHeartbeatMetadataSchema = z3.object({
+});
+var sdkHeartbeatMetadataSchema = z3.strictObject({
   sdk_version: z3.string(),
-  package_name: z3.string().nullable(),
+  package_name: z3.nullable(z3.string()),
   surface: z3.enum(["next", "react", "script"]),
   triggers: sdkHeartbeatTriggersSchema,
-  trigger_config: z3.record(z3.string(), z3.record(z3.string(), z3.unknown())).nullable().optional(),
-  configured_gtag_ids: z3.record(z3.string(), z3.string()).nullable().optional(),
+  trigger_config: z3.optional(z3.nullable(z3.record(z3.string(), z3.record(z3.string(), z3.unknown())))),
+  configured_gtag_ids: z3.optional(z3.nullable(z3.record(z3.string(), z3.string()))),
   // Site whose config object the SDK resolves; null on a legacy business ref.
-  config_site_id: z3.string().uuid().nullable().optional()
-}).strict();
-var sdkHeartbeatConfigSchema = z3.object({}).strict();
+  config_site_id: z3.optional(z3.nullable(z3.uuid()))
+});
+var sdkHeartbeatConfigSchema = z3.strictObject({});
 
 // ../tracking-core/src/events/form-start.ts
-import { z as z4 } from "zod";
-var formStartMetadataSchema = z4.object({
-  form: z4.object({
+import * as z4 from "zod/mini";
+var formStartMetadataSchema = z4.strictObject({
+  form: z4.strictObject({
     id: z4.string(),
-    action: z4.string().nullable()
-  }).strict(),
-  page: z4.object({
+    action: z4.nullable(z4.string())
+  }),
+  page: z4.strictObject({
     path: z4.string()
-  }).strict()
-}).strict();
-var formStartConfigSchema = z4.object({
-  selector: z4.string().optional()
-}).strict();
+  })
+});
+var formStartConfigSchema = z4.strictObject({
+  selector: z4.optional(z4.string())
+});
 
 // ../tracking-core/src/events/form-submit.ts
-import { z as z5 } from "zod";
+import * as z5 from "zod/mini";
 var jsonValueSchema = z5.lazy(
   () => z5.union([
     z5.string(),
-    z5.number().finite(),
+    z5.number(),
     z5.boolean(),
     z5.null(),
     z5.array(jsonValueSchema),
-    z5.record(jsonValueSchema)
+    z5.record(z5.string(), jsonValueSchema)
   ])
-);
-var formSubmitMetadataSchema = z5.object({
-  form: z5.object({
+).register(z5.globalRegistry, { id: "JsonSerializableValue" });
+var formSubmitMetadataSchema = z5.strictObject({
+  form: z5.strictObject({
     id: z5.string(),
-    action: z5.string().nullable(),
-    fields: z5.array(
-      z5.object({
-        name: z5.string(),
-        type: z5.string(),
-        label: z5.string().nullable(),
-        value: jsonValueSchema
-      }).strict()
-    ).optional()
-  }).strict(),
-  page: z5.object({
+    action: z5.nullable(z5.string()),
+    fields: z5.optional(
+      z5.array(
+        z5.strictObject({
+          name: z5.string(),
+          type: z5.string(),
+          label: z5.nullable(z5.string()),
+          value: jsonValueSchema
+        })
+      )
+    )
+  }),
+  page: z5.strictObject({
     path: z5.string()
-  }).strict()
-}).strict();
-var formSubmitConfigSchema = z5.object({}).strict();
+  })
+});
+var formSubmitConfigSchema = z5.strictObject({});
 
 // ../tracking-core/src/events/multi-page-session.ts
-import { z as z6 } from "zod";
-var multiPageSessionMetadataSchema = z6.object({
-  page_count: z6.number().int().min(2),
-  page: z6.object({
+import * as z6 from "zod/mini";
+var multiPageSessionMetadataSchema = z6.strictObject({
+  page_count: z6.int().check(z6.gte(2)),
+  page: z6.strictObject({
     path: z6.string()
-  }).strict()
-}).strict();
-var multiPageSessionConfigSchema = z6.object({
-  pageThreshold: z6.number().int().min(2)
-}).strict();
+  })
+});
+var multiPageSessionConfigSchema = z6.strictObject({
+  pageThreshold: z6.int().check(z6.gte(2))
+});
 
 // ../tracking-core/src/events/page-exit.ts
-import { z as z7 } from "zod";
-var pageExitMetadataSchema = z7.object({
-  dwell_ms: z7.number().int().min(0),
+import * as z7 from "zod/mini";
+var pageExitMetadataSchema = z7.strictObject({
+  dwell_ms: z7.int().check(z7.gte(0)),
   // null = left without any scroll signal; floor is 0 so a valid 0% is never
   // rejected (a single bad field 422s the whole keepalive beacon batch).
-  max_scroll_percent: z7.number().int().min(0).max(100).nullable(),
+  max_scroll_percent: z7.nullable(z7.int().check(z7.gte(0), z7.lte(100))),
   // The gating baseline: the fraction of the page visible at load with
   // zero scrolling — or, for pages that grew after the post-paint snapshot
   // (skeleton/streaming renders), the first-scroll position that
   // established it. null = page had no scrollable range, or the segment
-  // ended before the snapshot. `.optional()` is load-bearing: SDK builds
+  // ended before the snapshot. Optionality is load-bearing: SDK builds
   // predating this field keep POSTing page_exit without the key —
   // requiring it would 422 whole keepalive beacon batches.
-  scroll_baseline_percent: z7.number().int().min(0).max(100).nullable().optional(),
-  page: z7.object({
+  scroll_baseline_percent: z7.optional(z7.nullable(z7.int().check(z7.gte(0), z7.lte(100)))),
+  page: z7.strictObject({
     path: z7.string()
-  }).strict()
-}).strict();
-var pageExitConfigSchema = z7.object({}).strict();
+  })
+});
+var pageExitConfigSchema = z7.strictObject({});
 
 // ../tracking-core/src/events/phone-click.ts
-import { z as z8 } from "zod";
-var phoneClickMetadataSchema = z8.object({
+import * as z8 from "zod/mini";
+var phoneClickMetadataSchema = z8.strictObject({
   phone_number: z8.string(),
-  page: z8.object({
+  page: z8.strictObject({
     path: z8.string()
-  }).strict(),
-  section: z8.string().nullable().optional()
-}).strict();
-var phoneClickConfigSchema = z8.object({
-  autoCapture: z8.object({
-    selector: z8.string().optional()
-  }).strict().optional()
-}).strict();
+  }),
+  section: z8.optional(z8.nullable(z8.string()))
+});
+var phoneClickConfigSchema = z8.strictObject({
+  autoCapture: z8.optional(
+    z8.strictObject({
+      selector: z8.optional(z8.string())
+    })
+  )
+});
 
 // ../tracking-core/src/events/scroll-depth.ts
-import { z as z9 } from "zod";
-var scrollDepthMetadataSchema = z9.object({
-  depth_percent: z9.number().int().min(1).max(100),
-  page: z9.object({
+import * as z9 from "zod/mini";
+var scrollDepthMetadataSchema = z9.strictObject({
+  depth_percent: z9.int().check(z9.gte(1), z9.lte(100)),
+  page: z9.strictObject({
     path: z9.string()
-  }).strict()
-}).strict();
-var scrollDepthConfigSchema = z9.object({
-  thresholds: z9.array(z9.number().int().min(1).max(100)).min(1)
-}).strict();
+  })
+});
+var scrollDepthConfigSchema = z9.strictObject({
+  thresholds: z9.array(z9.int().check(z9.gte(1), z9.lte(100))).check(z9.minLength(1))
+});
 
 // ../tracking-core/src/events/specific-page-visit.ts
-import { z as z10 } from "zod";
+import * as z10 from "zod/mini";
 var PAGE_IDENTITY_MAX_LENGTH = 64;
 var PAGE_IDENTITY_PATTERN = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
-var pageIdentitySchema = z10.string().max(PAGE_IDENTITY_MAX_LENGTH).regex(PAGE_IDENTITY_PATTERN, {
-  message: "page identity must be lowercase snake_case, start with a letter, and contain at most 64 characters"
-});
+var pageIdentitySchema = z10.string().check(
+  z10.maxLength(PAGE_IDENTITY_MAX_LENGTH),
+  z10.regex(PAGE_IDENTITY_PATTERN, {
+    message: "page identity must be lowercase snake_case, start with a letter, and contain at most 64 characters"
+  })
+);
 var specificPageNameSchema = pageIdentitySchema;
-var specificPageVisitMetadataSchema = z10.object({
+var specificPageVisitMetadataSchema = z10.strictObject({
   page_name: specificPageNameSchema,
-  page: z10.object({
+  page: z10.strictObject({
     path: z10.string()
-  }).strict()
-}).strict();
-var specificPageVisitConfigSchema = z10.object({
+  })
+});
+var specificPageVisitConfigSchema = z10.strictObject({
   pages: z10.array(
-    z10.object({
+    z10.strictObject({
       name: specificPageNameSchema,
       pathPattern: z10.custom((value) => value instanceof RegExp, {
         message: "pathPattern must be a RegExp"
       })
-    }).strict()
-  ).min(1)
-}).strict();
+    })
+  ).check(z10.minLength(1))
+});
 
 // ../tracking-core/src/events/time-on-site.ts
-import { z as z11 } from "zod";
-var timeOnSiteMetadataSchema = z11.object({
-  duration_ms: z11.number().int().nonnegative(),
-  page: z11.object({
+import * as z11 from "zod/mini";
+var timeOnSiteMetadataSchema = z11.strictObject({
+  duration_ms: z11.int().check(z11.nonnegative()),
+  page: z11.strictObject({
     path: z11.string()
-  }).strict()
-}).strict();
-var timeOnSiteConfigSchema = z11.object({
-  thresholdSeconds: z11.number().int().positive()
-}).strict();
+  })
+});
+var timeOnSiteConfigSchema = z11.strictObject({
+  thresholdSeconds: z11.int().check(z11.positive())
+});
 
 // ../tracking-core/src/events/semantics.ts
 var EVENT_SEMANTICS = {
@@ -2289,7 +2308,7 @@ function createTypedClient(raw, registry, options = {}) {
     trackEvent(eventType, metadata, opts) {
       if (debug) {
         const def = getEventDefinition(eventType);
-        def.metadataSchema.parse(metadata);
+        parse2(def.metadataSchema, metadata);
       }
       raw.trackEvent({
         eventType,
@@ -2778,117 +2797,6 @@ function attachPhoneClickCapture(client, config) {
   };
 }
 
-// ../tracking-core/src/resources/sales/schema.ts
-import { z as z12 } from "zod";
-var SUPPORTED_CURRENCIES = ["USD", "CAD"];
-var TRACKING_ENVIRONMENTS = ["production", "development"];
-var currencySchema = z12.enum(SUPPORTED_CURRENCIES);
-var centsSchema = z12.number().int().nonnegative();
-var quantitySchema = z12.string().regex(/^\d+(\.\d{1,3})?$/);
-var metadataSchema = z12.record(z12.unknown());
-var saleItemSchema = z12.object({
-  external_item_id: z12.string().nullable().optional(),
-  name: z12.string().nullable().optional(),
-  category: z12.string().nullable().optional(),
-  quantity: quantitySchema,
-  unit_price_cents: centsSchema,
-  // Non-negativity validated on the wire — same contract as the other cents
-  // fields — and backstopped by the DB CHECK.
-  unit_cost_cents: centsSchema.nullable().optional()
-}).strict();
-var saleServiceSchema = z12.object({
-  service: z12.string(),
-  amount_cents: centsSchema
-}).strict();
-var customerNameSchema = z12.string().max(200);
-var customerPhoneSchema = z12.string().max(64);
-var customerEmailSchema = z12.string().max(320).email();
-function refineServiceXor(val, ctx, { requireAmount }) {
-  if (val.services != null) {
-    if (val.service != null) {
-      ctx.addIssue({
-        code: z12.ZodIssueCode.custom,
-        message: "pass either `service` or `services`, not both",
-        path: ["services"]
-      });
-    }
-    if (val.services.length === 0) {
-      ctx.addIssue({
-        code: z12.ZodIssueCode.custom,
-        message: "`services` must not be empty",
-        path: ["services"]
-      });
-    }
-    const keys = val.services.map((s) => s.service);
-    if (new Set(keys).size !== keys.length) {
-      ctx.addIssue({
-        code: z12.ZodIssueCode.custom,
-        message: "`services` must not list the same service more than once",
-        path: ["services"]
-      });
-    }
-    if (val.amount_total_cents != null) {
-      const sum = val.services.reduce((acc, s) => acc + s.amount_cents, 0);
-      if (val.amount_total_cents !== sum) {
-        ctx.addIssue({
-          code: z12.ZodIssueCode.custom,
-          message: "amount_total_cents must equal the sum of the services amounts (omit it to derive it automatically)",
-          path: ["amount_total_cents"]
-        });
-      }
-    }
-  } else if (requireAmount && val.amount_total_cents == null) {
-    ctx.addIssue({
-      code: z12.ZodIssueCode.custom,
-      message: "amount_total_cents is required unless `services` is provided",
-      path: ["amount_total_cents"]
-    });
-  }
-}
-var saleCreateSchema = z12.object({
-  external_id: z12.string().nullable().optional(),
-  description: z12.string().nullable().optional(),
-  service: z12.string().nullable().optional(),
-  services: z12.array(saleServiceSchema).nullable().optional(),
-  currency: currencySchema,
-  // Optional only because the plural `services` form derives it from the sum
-  // (see refineServiceXor); the singular/serviceless path still requires it.
-  amount_total_cents: centsSchema.nullable().optional(),
-  occurred_at: z12.string().datetime(),
-  environment: z12.enum(TRACKING_ENVIRONMENTS).default("production"),
-  items: z12.array(saleItemSchema).default([]),
-  metadata: metadataSchema.nullable().optional(),
-  customer_name: customerNameSchema.nullable().optional(),
-  customer_phone: customerPhoneSchema.nullable().optional(),
-  customer_email: customerEmailSchema.nullable().optional(),
-  // CASL consent attestation: the customer agreed to receive SMS. Recorded
-  // with a timestamp server-side; every SMS send path gates on it.
-  //
-  // Tri-state: omit it (or send null) to let the server apply the business's
-  // configured default-opt-in policy, honouring a returning customer's
-  // remembered preference. Send an explicit boolean to assert consent state
-  // yourself — `false` records a deliberate opt-out.
-  sms_consent: z12.boolean().nullable().optional()
-}).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: true }));
-var saleUpdateSchema = z12.object({
-  description: z12.string().nullable().optional(),
-  service: z12.string().nullable().optional(),
-  services: z12.array(saleServiceSchema).nullable().optional(),
-  currency: currencySchema.optional(),
-  amount_total_cents: centsSchema.optional(),
-  occurred_at: z12.string().datetime().optional(),
-  items: z12.array(saleItemSchema).optional(),
-  metadata: metadataSchema.nullable().optional(),
-  customer_name: customerNameSchema.nullable().optional(),
-  // Re-attest when changing a filler-looking name; the server clears the
-  // prior attestation whenever `customer_name` changes.
-  customer_name_placeholder_confirmed: z12.boolean().optional(),
-  customer_phone: customerPhoneSchema.nullable().optional(),
-  customer_email: customerEmailSchema.nullable().optional(),
-  // NOT NULL server-side: omit to leave unchanged (explicit null is rejected).
-  sms_consent: z12.boolean().optional()
-}).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: false }));
-
 // src/hooks.ts
 function useGclid() {
   const [gclid, setGclid] = useState(null);
@@ -3229,7 +3137,7 @@ function GoogleAdsTracking(props) {
 import { usePathname, useSearchParams } from "next/navigation";
 
 // package.json
-var version = "0.27.0";
+var version = "1.0.0";
 
 // src/factory.tsx
 import {