@scalebun-release/react-native 2.5.0

package/lib/module/vendor/protocol/internal/validation.js

@@ -0,0 +1,423 @@
+/**
+ * Internal validation — a tiny, dependency-free, Metro-friendly validator.
+ *
+ * This is NOT a general-purpose schema library. It implements only the exact
+ * subset of the Zod API surface that the ScaleBun SDK protocol + config schemas
+ * use, so we can drop the runtime `zod` dependency entirely.
+ *
+ * Supported builders : string, number, boolean, literal, enum, object, array,
+ *                       record, unknown/any, discriminatedUnion.
+ * Supported modifiers : .optional(), .nullable(), .default(), .refine(),
+ *                       string .min()/.url(), number .int()/.min()/.max(),
+ *                       object .extend().
+ * Result API          : .parse() (throws), .safeParse() (no-throw), with an
+ *                       error exposing `.issues` and `.format()`.
+ *
+ * The public `z` object below is a drop-in for the small slice of the Zod `z`
+ * builder the schemas relied on. Use `Infer<typeof Schema>` in place of
+ * `z.infer<...>`.
+ *
+ * Builder functions return narrow public INTERFACES (no private fields, no
+ * unique-symbol types) so TypeScript declaration emit stays clean for the
+ * exported schema constants.
+ */
+
+// ─── Result + issue shapes ───────────────────────────────────────────────────
+
+/** Recursive shape returned by ValidationError.format(), mirroring Zod's. */
+
+export class ValidationError extends Error {
+  constructor(issues) {
+    super(issues.map(i => `${i.path.join('.') || '(root)'}: ${i.message}`).join('; '));
+    this.name = 'ValidationError';
+    this.issues = issues;
+  }
+
+  /** Nested error object keyed by path, matching Zod's `error.format()`. */
+  format() {
+    const root = {
+      _errors: []
+    };
+    for (const issue of this.issues) {
+      if (issue.path.length === 0) {
+        root._errors.push(issue.message);
+        continue;
+      }
+      let node = root;
+      for (let i = 0; i < issue.path.length; i++) {
+        const key = String(issue.path[i]);
+        const existing = node[key];
+        let child;
+        if (existing && !Array.isArray(existing)) {
+          child = existing;
+        } else {
+          child = {
+            _errors: []
+          };
+          node[key] = child;
+        }
+        if (i === issue.path.length - 1) {
+          child._errors.push(issue.message);
+        }
+        node = child;
+      }
+    }
+    return root;
+  }
+}
+
+// ─── Internal parse plumbing ────────────────────────────────────────────────
+
+/** Sentinel returned by `_parse` on failure. A plain branded object (not a
+ *  unique symbol) so it serializes cleanly in `.d.ts` output. */
+
+export const FAIL = {
+  __validationFail: true
+};
+function addIssue(ctx, path, message) {
+  ctx.issues.push({
+    path,
+    message
+  });
+  return FAIL;
+}
+
+// ─── Public schema interfaces ────────────────────────────────────────────────
+
+// ─── Object output type inference ─────────────────────────────────────────────
+
+/** Output type of a schema — drop-in for `z.infer<typeof Schema>`. */
+
+// ─── Base class ────────────────────────────────────────────────────────────────
+
+class BaseSchema {
+  safeParse(input) {
+    const ctx = {
+      issues: []
+    };
+    const result = this._parse(input, [], ctx);
+    if (result === FAIL || ctx.issues.length > 0) {
+      return {
+        success: false,
+        error: new ValidationError(ctx.issues)
+      };
+    }
+    return {
+      success: true,
+      data: result
+    };
+  }
+  parse(input) {
+    const r = this.safeParse(input);
+    if (!r.success) throw r.error;
+    return r.data;
+  }
+  optional() {
+    return new OptionalSchema(this);
+  }
+  nullable() {
+    return new NullableSchema(this);
+  }
+  default(value) {
+    return new DefaultSchema(this, value);
+  }
+  refine(check, message) {
+    return new RefineSchema(this, check, typeof message === 'string' ? message : message.message);
+  }
+}
+
+// ─── string ───────────────────────────────────────────────────────────────────
+
+class StringSchema extends BaseSchema {
+  _url = false;
+  min(n, message) {
+    this._min = n;
+    this._minMsg = message;
+    return this;
+  }
+  url(message) {
+    this._url = true;
+    this._urlMsg = message;
+    return this;
+  }
+  _parse(input, path, ctx) {
+    if (typeof input !== 'string') {
+      return addIssue(ctx, path, `Expected string, received ${typeofName(input)}`);
+    }
+    if (this._min !== undefined && input.length < this._min) {
+      return addIssue(ctx, path, this._minMsg ?? `String must contain at least ${this._min} character(s)`);
+    }
+    if (this._url && !isValidUrl(input)) {
+      return addIssue(ctx, path, this._urlMsg ?? 'Invalid url');
+    }
+    return input;
+  }
+}
+
+// ─── number ───────────────────────────────────────────────────────────────────
+
+class NumberSchema extends BaseSchema {
+  _int = false;
+  int() {
+    this._int = true;
+    return this;
+  }
+  min(n) {
+    this._min = n;
+    return this;
+  }
+  max(n) {
+    this._max = n;
+    return this;
+  }
+  _parse(input, path, ctx) {
+    if (typeof input !== 'number' || Number.isNaN(input)) {
+      return addIssue(ctx, path, `Expected number, received ${typeofName(input)}`);
+    }
+    if (this._int && !Number.isInteger(input)) {
+      return addIssue(ctx, path, 'Expected integer, received float');
+    }
+    if (this._min !== undefined && input < this._min) {
+      return addIssue(ctx, path, `Number must be greater than or equal to ${this._min}`);
+    }
+    if (this._max !== undefined && input > this._max) {
+      return addIssue(ctx, path, `Number must be less than or equal to ${this._max}`);
+    }
+    return input;
+  }
+}
+
+// ─── boolean ───────────────────────────────────────────────────────────────────
+
+class BooleanSchema extends BaseSchema {
+  _parse(input, path, ctx) {
+    if (typeof input !== 'boolean') {
+      return addIssue(ctx, path, `Expected boolean, received ${typeofName(input)}`);
+    }
+    return input;
+  }
+}
+
+// ─── literal ───────────────────────────────────────────────────────────────────
+
+class LiteralSchema extends BaseSchema {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  _parse(input, path, ctx) {
+    if (input !== this.value) {
+      return addIssue(ctx, path, `Invalid literal value, expected ${JSON.stringify(this.value)}`);
+    }
+    return input;
+  }
+}
+
+// ─── enum ───────────────────────────────────────────────────────────────────────
+
+class EnumSchema extends BaseSchema {
+  constructor(values) {
+    super();
+    this.values = values;
+  }
+  _parse(input, path, ctx) {
+    if (typeof input !== 'string' || !this.values.includes(input)) {
+      return addIssue(ctx, path, `Invalid enum value. Expected ${this.values.map(v => `'${v}'`).join(' | ')}`);
+    }
+    return input;
+  }
+}
+
+// ─── array ───────────────────────────────────────────────────────────────────────
+
+class ArraySchema extends BaseSchema {
+  constructor(element) {
+    super();
+    this.element = element;
+  }
+  _parse(input, path, ctx) {
+    if (!Array.isArray(input)) {
+      return addIssue(ctx, path, `Expected array, received ${typeofName(input)}`);
+    }
+    const out = [];
+    let ok = true;
+    for (let i = 0; i < input.length; i++) {
+      const r = this.element._parse(input[i], [...path, i], ctx);
+      if (r === FAIL) ok = false;else out.push(r);
+    }
+    return ok ? out : FAIL;
+  }
+}
+
+// ─── record ───────────────────────────────────────────────────────────────────────
+
+class RecordSchema extends BaseSchema {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  _parse(input, path, ctx) {
+    if (!isPlainObject(input)) {
+      return addIssue(ctx, path, `Expected object, received ${typeofName(input)}`);
+    }
+    const out = {};
+    let ok = true;
+    for (const key of Object.keys(input)) {
+      const r = this.value._parse(input[key], [...path, key], ctx);
+      if (r === FAIL) ok = false;else out[key] = r;
+    }
+    return ok ? out : FAIL;
+  }
+}
+
+// ─── unknown / any ─────────────────────────────────────────────────────────────
+
+class UnknownSchema extends BaseSchema {
+  _parse(input) {
+    return input;
+  }
+}
+
+// ─── object ───────────────────────────────────────────────────────────────────────
+
+class ObjectSchema extends BaseSchema {
+  constructor(shape) {
+    super();
+    this.shape = shape;
+  }
+  extend(extension) {
+    return new ObjectSchema({
+      ...this.shape,
+      ...extension
+    });
+  }
+  _parse(input, path, ctx) {
+    if (!isPlainObject(input)) {
+      return addIssue(ctx, path, `Expected object, received ${typeofName(input)}`);
+    }
+    const out = {};
+    let ok = true;
+    for (const key of Object.keys(this.shape)) {
+      const r = this.shape[key]._parse(input[key], [...path, key], ctx);
+      if (r === FAIL) ok = false;else if (r !== undefined || key in input) out[key] = r;
+    }
+    // Unknown keys are stripped (Zod's default `.strip()` behaviour).
+    return ok ? out : FAIL;
+  }
+}
+
+// ─── discriminated union ────────────────────────────────────────────────────────
+
+class DiscriminatedUnionSchema extends BaseSchema {
+  constructor(key, options) {
+    super();
+    this.key = key;
+    this.options = options;
+  }
+  _parse(input, path, ctx) {
+    if (!isPlainObject(input)) {
+      return addIssue(ctx, path, `Expected object, received ${typeofName(input)}`);
+    }
+    const discriminator = input[this.key];
+    const match = this.options.find(opt => {
+      const field = opt.shape?.[this.key];
+      return field instanceof LiteralSchema && field.value === discriminator;
+    });
+    if (!match) {
+      return addIssue(ctx, [...path, this.key], `Invalid discriminator value ${JSON.stringify(discriminator)}`);
+    }
+    const r = match._parse(input, path, ctx);
+    return r === FAIL ? FAIL : r;
+  }
+}
+
+// ─── modifiers ───────────────────────────────────────────────────────────────────
+
+class OptionalSchema extends BaseSchema {
+  constructor(inner) {
+    super();
+    this.inner = inner;
+  }
+  _parse(input, path, ctx) {
+    if (input === undefined) return undefined;
+    return this.inner._parse(input, path, ctx);
+  }
+}
+class NullableSchema extends BaseSchema {
+  constructor(inner) {
+    super();
+    this.inner = inner;
+  }
+  _parse(input, path, ctx) {
+    if (input === null) return null;
+    return this.inner._parse(input, path, ctx);
+  }
+}
+class DefaultSchema extends BaseSchema {
+  constructor(inner, defaultValue) {
+    super();
+    this.inner = inner;
+    this.defaultValue = defaultValue;
+  }
+  _parse(input, path, ctx) {
+    const value = input === undefined ? typeof this.defaultValue === 'function' ? this.defaultValue() : this.defaultValue : input;
+    return this.inner._parse(value, path, ctx);
+  }
+}
+class RefineSchema extends BaseSchema {
+  constructor(inner, check, message) {
+    super();
+    this.inner = inner;
+    this.check = check;
+    this.message = message;
+  }
+  _parse(input, path, ctx) {
+    const r = this.inner._parse(input, path, ctx);
+    if (r === FAIL) return FAIL;
+    if (!this.check(r)) {
+      return addIssue(ctx, path, this.message);
+    }
+    return r;
+  }
+}
+
+// ─── helpers ───────────────────────────────────────────────────────────────────
+
+function typeofName(value) {
+  if (value === null) return 'null';
+  if (Array.isArray(value)) return 'array';
+  return typeof value;
+}
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isValidUrl(value) {
+  const URLCtor = globalThis.URL;
+  try {
+    if (typeof URLCtor !== 'undefined') {
+      // eslint-disable-next-line no-new
+      new URLCtor(value);
+      return /^[a-z][a-z0-9+.-]*:\/\//i.test(value);
+    }
+  } catch {
+    return false;
+  }
+  return /^[a-z][a-z0-9+.-]*:\/\/[^\s]+$/i.test(value);
+}
+
+// ─── public `z` builder (Zod-subset drop-in) ─────────────────────────────────────
+
+export const z = {
+  string: () => new StringSchema(),
+  number: () => new NumberSchema(),
+  boolean: () => new BooleanSchema(),
+  literal: value => new LiteralSchema(value),
+  enum: values => new EnumSchema(values),
+  object: shape => new ObjectSchema(shape),
+  array: element => new ArraySchema(element),
+  record: value => new RecordSchema(value),
+  unknown: () => new UnknownSchema(),
+  any: () => new UnknownSchema(),
+  discriminatedUnion: (key, options) => new DiscriminatedUnionSchema(key, options)
+};
+//# sourceMappingURL=validation.js.map

package/lib/module/vendor/sdk-contracts/bridge.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=bridge.js.map

package/lib/module/vendor/sdk-contracts/config.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=config.js.map

package/lib/module/vendor/sdk-contracts/events.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=events.js.map

package/lib/module/vendor/sdk-contracts/features.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=features.js.map

package/lib/module/vendor/sdk-contracts/index.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=index.js.map

package/lib/module/vendor/sdk-contracts/platform.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=platform.js.map

package/lib/module/vendor/sdk-contracts/session-boundary.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session-boundary.js.map

package/lib/module/vendor/sdk-contracts/session.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=session.js.map

package/lib/module/vendor/vendor.manifest

@@ -0,0 +1,10 @@
+sdk-contracts/bridge.ts 1d1ca0a560d7dc2f7cd6e3e64b9359363cafd9b572f9610e5c1b244876f378c3
+sdk-contracts/config.ts e5337de3badabc9a2abc7af7ac8dd8ea98bd67ae6f69baa630029448ca83dcd1
+sdk-contracts/events.ts 99d9f236e39a09c808750c394f851687c59b8c3490d2c36cd9484389f3299162
+sdk-contracts/features.ts a747e9b72f659d952cd52632021f39435cd035461c0d8f40093c8f1ab06bbdba
+sdk-contracts/index.ts d0131282dbdadf26e7fb7cd2b5109849a324bc570fc7d7370158279691ed476e
+sdk-contracts/platform.ts 6fa39ca1633195a66184d5182ed86911d2fa2ca92b53b113123b78a574db48b6
+sdk-contracts/session-boundary.ts 4009621006421ddfc5174369dd7e68340272c5603a357dd7ca7b740f1e0d13d3
+sdk-contracts/session.ts a6811758d0d3f9c149ccb3e8b5a0f02726f129a08560c6b968b4c95d3b2685f1
+protocol/index.ts a0a0a57213d8901658f6ec1c256bc7deb0587f38aa51a98a80e981be46b63a1f
+protocol/internal/validation.ts ec607b58f65cea923f3b990065a66528c49545136e2d2be223d94c5e41009cb7

package/lib/typescript/analytics/EventTracker.d.ts

@@ -0,0 +1,197 @@
+/**
+ * ScaleBun SDK — Phase 1 Envelope Event Tracker
+ *
+ * A small, self-contained lane that emits the Phase 1 event envelope to
+ * `POST {apiBaseUrl}/batch`. Deliberately decoupled from the replay/analytics
+ * pipeline so it can ship without touching it.
+ *
+ * Responsibilities:
+ *  - stable installation_id + anonymous_id (persisted via StorageBackend)
+ *  - session_id per launch
+ *  - first_open exactly once per installation
+ *  - app_open / session_start on start()
+ *  - client-side event_id
+ *  - offline queue (persisted) + batch flush + exponential backoff
+ *  - never throws / never crashes the host app on network failure
+ *  - optional idfa / gaid / idfv identifiers (set, never required)
+ *
+ * Public methods mirror the Phase 1 contract: track / identify / trackPurchase / flush.
+ */
+import { type RevenueInput } from './revenue';
+import { type SubscriptionInput } from './subscription';
+/**
+ * Exported because this is THE canonical per-install identity key for the whole
+ * SDK. The OTA lane used to demand a caller-supplied installationId instead of
+ * reading this one, which put OTA telemetry in its own id namespace — every
+ * join from OTA to CDP (blast radius, MRR-at-risk, churn) matched by luck.
+ * One install, one id, every lane.
+ */
+export declare const K_INSTALLATION_ID = "scalebun_installation_id";
+export type EventPlatform = 'ios' | 'android' | 'web' | 'react_native';
+export interface EventTrackerConfig {
+    appId: string;
+    clientKey: string;
+    apiBaseUrl: string;
+    platform?: EventPlatform;
+    appVersion?: string;
+    osVersion?: string;
+    country?: string;
+    flushIntervalMs?: number;
+    batchSize?: number;
+    autoLifecycleEvents?: boolean;
+    /**
+     * Subscribe to the zero-instrumentation collector bus (screens, deep links,
+     * interactions, push and Engage outcomes). Default false so upgrading an
+     * existing `ScaleBun.init()` integration cannot silently increase volume.
+     * `ScaleBunProvider` opts in explicitly.
+     */
+    automaticEventTracking?: boolean;
+    /** Static context fields (sdk_version, device_model, manufacturer, language, timezone, network_type). */
+    context?: Record<string, any>;
+    /**
+     * Best-effort observer fired for every tracked event (incl. auto-lifecycle like
+     * first_open). Used by the SKAN CV manager to auto-apply conversion values. Must
+     * never throw; the tracker guards it regardless.
+     */
+    onEvent?: (eventName: string, revenue?: number) => void;
+    /**
+     * Canonical foreground session supplied by the shared session subsystem.
+     * Falls back to this tracker's local id when that subsystem is unavailable.
+     */
+    sessionIdProvider?: () => string | null | undefined;
+}
+export interface AdIdentifiers {
+    idfa?: string;
+    gaid?: string;
+    idfv?: string;
+    /** Phase 2: deferred deep-link click token, for deterministic install attribution. */
+    click_id?: string;
+}
+/** Live event-lane diagnostics. Counters reset when the SDK process creates a new tracker. */
+export interface EventTrackerStats {
+    pending: number;
+    dropped: number;
+}
+export declare class EventTracker {
+    private storage;
+    private cfg;
+    private installationId;
+    private anonymousId;
+    private sessionId;
+    private userId?;
+    private identifiers;
+    private stamps;
+    private queue;
+    private timer;
+    private flushing;
+    private failureCount;
+    private droppedCount;
+    private started;
+    private automaticEventsUnsubscribe;
+    private quotaUnsubscribe;
+    constructor(config: EventTrackerConfig);
+    /** Drop every queued envelope: the server would refuse them and must not be retried. */
+    private purgeForQuota;
+    /** Stable per-install id (survives push-token rotation). */
+    getInstallationId(): string;
+    /** Events waiting for delivery and events intentionally dropped by bounded validation/queues. */
+    get stats(): EventTrackerStats;
+    start(): void;
+    /**
+     * Emit `app_update` when the running app version differs from the one last seen on this device.
+     *
+     * The last-seen version is stored regardless of the outcome, so the very first run after this
+     * feature ships records a baseline WITHOUT claiming an upgrade happened — the alternative
+     * (treating "no stored version" as an update) would fire a false `app_update` for every existing
+     * installation on the day it rolls out.
+     */
+    private maybeAppUpdate;
+    /** Start a fresh session (e.g. after the app returns from a long background). */
+    newSession(): void;
+    /**
+     * Hand the live session id to the native crash layer.
+     *
+     * Called at EVERY point the id changes — construction and rollover — because a crash-safe copy
+     * that is one session stale is worse than none: it would confidently attribute a crash to a
+     * session that had already ended.
+     *
+     * Fire-and-forget. Native persists it synchronously on its own side; a failure here degrades a
+     * recovered crash to unattributed, which is exactly the behaviour before this existed, and must
+     * never be able to fail a session start.
+     */
+    private publishSessionToNative;
+    identify(userId: string, traits?: Record<string, any>): void;
+    /** Stop attaching an identified user after logout; installation identity remains. */
+    clearIdentity(): void;
+    /** Set optional ad identifiers; they ride on every subsequent event. None required. */
+    setIdentifiers(ids: AdIdentifiers): void;
+    /**
+     * Phase 4: stamp a persistent property onto every subsequent event (e.g. an
+     * experiment assignment `experiment_<key>=<variant>`). Explicit per-event
+     * properties win over a stamp with the same key.
+     */
+    stamp(key: string, value: any): void;
+    /**
+     * Phase 2: record a deferred deep-link click token (from a tracking-link landing
+     * or install referrer). It rides on `identifiers.click_id` of every subsequent
+     * event — notably first_open — so the backend attributes the install deterministically.
+     * Persisted so it survives the click→install→open gap. Call BEFORE start() ideally.
+     */
+    setAttributionClickId(clickId: string): void;
+    track(eventName: string, properties?: Record<string, any>, timestamp?: number): void;
+    /**
+     * A purchase, normalized through the shared revenue rules.
+     *
+     * This used to spread the caller's object straight onto the envelope, which
+     * made mobile disagree with web on the two things a revenue report is built
+     * from: a refund kept whatever sign the caller gave it (so an iOS refund
+     * ADDED to gross revenue and to the customer's lifetime value), and
+     * `productId` never became the `product_id` the rollup groups plans by, so
+     * every mobile sale landed in "Unattributed". See revenue.ts for the full
+     * list and why the property names are the web SDK's.
+     *
+     * A rejected input is DROPPED, with a dev-time warning. A purchase with no
+     * transaction id cannot be deduplicated, and enqueuing it anyway is how one
+     * retried network call becomes two sales.
+     */
+    trackPurchase(input: RevenueInput): void;
+    /**
+     * Record an event-sourced subscription state change for the recurring-
+     * revenue ledger. This bypasses generic `$` event routing deliberately:
+     * `$subscription` belongs on the durable analytics `/batch` lane.
+     */
+    trackSubscription(input: SubscriptionInput): void;
+    flush(): Promise<void>;
+    /** Read a /v1/batch response for a quota refusal. Never throws. */
+    private noteQuota;
+    stop(): void;
+    /**
+     * Fold in device facts that were not knowable at init.
+     *
+     * `Platform.constants` answers Android synchronously, so its model and manufacturer ride the
+     * very first event. iOS exposes neither there — only the native bridge knows, and the bridge is
+     * async and may not be installed at all. Without this the iOS half of every install reported no
+     * model whatsoever.
+     *
+     * `buildEnvelope` reads `cfg.context` per event, so applying it here reaches every event from
+     * the next one onward. Detected keys WIN over whatever the integrator configured, for the same
+     * reason `mergeDeviceContext` inverts the usual precedence: a measurement must not be
+     * overridable by a guess. Empty patches are ignored so a bridge that answered with nothing
+     * cannot blank a value the static path already found.
+     */
+    applyDetectedContext(patch: Record<string, string>): void;
+    private buildEnvelope;
+    private enqueue;
+    private scheduleFlush;
+    private loadOrCreate;
+    private persistQueue;
+    private loadQueue;
+    private loadClickId;
+    get ids(): {
+        installationId: string;
+        anonymousId: string;
+        sessionId: string;
+        userId: string | undefined;
+    };
+}
+//# sourceMappingURL=EventTracker.d.ts.map