@usergist/sdk-core 0.1.0 → 0.1.2

package/dist/client.js

@@ -0,0 +1,1170 @@
+import { z } from 'zod';
+
+// src/types/segment-dsl.ts
+function emptySegmentDsl() {
+  return { version: 1, root: { combinator: "AND", predicates: [] } };
+}
+
+// src/types/api.ts
+function ok(data, meta) {
+  return meta ? { success: true, data, meta } : { success: true, data };
+}
+function err(code, message, details) {
+  return {
+    success: false,
+    error: details === void 0 ? { code, message } : { code, message, details }
+  };
+}
+
+// src/types/workspace.ts
+function defaultOnboardingMessage(appName) {
+  return {
+    title: `Welcome to ${appName.trim() || "our app"}`,
+    body: "Glad you\u2019re here. Take a look around and make yourself at home.",
+    buttonLabel: "Got it",
+    format: "modal"
+  };
+}
+
+// src/types/survey.ts
+var SURVEY_END_SENTINEL = "__end__";
+
+// src/types/inapp-message.ts
+var INAPP_SHOWN_EVENT_NAME = "$inapp_shown";
+var INAPP_DISMISSED_EVENT_NAME = "$inapp_dismissed";
+var INAPP_AUTO_DISMISSED_EVENT_NAME = "$inapp_auto_dismissed";
+var INAPP_CTA_CLICKED_EVENT_NAME = "$inapp_cta_clicked";
+
+// src/types/request.ts
+var REQUEST_SUBMITTED_EVENT_NAME = "$request_submitted";
+var REQUEST_UPVOTED_EVENT_NAME = "$request_upvoted";
+var REQUEST_UNUPVOTED_EVENT_NAME = "$request_unupvoted";
+var REQUEST_FOLLOWED_EVENT_NAME = "$request_followed";
+var REQUEST_UNFOLLOWED_EVENT_NAME = "$request_unfollowed";
+var REQUEST_STATUS_CHANGED_EVENT_NAME = "$request_status_changed";
+var REQUEST_RESPONDED_EVENT_NAME = "$request_responded";
+var REQUEST_COMMENTED_EVENT_NAME = "$request_commented";
+var REQUEST_COMMENT_EDITED_EVENT_NAME = "$request_comment_edited";
+var REQUEST_COMMENT_DELETED_EVENT_NAME = "$request_comment_deleted";
+
+// src/types/targeting.ts
+function emptyAudienceSpec() {
+  return { version: 1, mode: "everyone", combinator: "all", conditions: [] };
+}
+var APP_OPEN_EVENT_NAME = "$app_open";
+var AUDIENCE_JOIN_EVENT_NAME = "$audience_join";
+var AUDIENCE_JOIN_TRIGGER_KIND = "audience_join";
+var APP_VERSION_CHANGED_EVENT_NAME = "$app_version_changed";
+function defaultTriggerSpec() {
+  return { kind: "app_open" };
+}
+function defaultEventTrigger(eventName = "") {
+  return {
+    kind: "event",
+    eventName,
+    occurrence: { mode: "every" }
+  };
+}
+
+// src/types/themes.ts
+var RADIUS_PRESETS = {
+  sharp: 4,
+  soft: 12,
+  rounded: 20,
+  pill: 999
+};
+var JAKARTA = "Plus Jakarta Sans";
+var THEME_PRESETS = [
+  {
+    id: "minimal",
+    name: "Minimal",
+    description: "Clean neutral palette",
+    colors: {
+      primary: "#111827",
+      background: "#FFFFFF",
+      text: "#111827",
+      subtext: "#6B7280",
+      border: "#E5E7EB",
+      button: "#111827"
+    },
+    radius: 16,
+    fontFamily: JAKARTA,
+    swatches: ["#111827", "#FFFFFF", "#E5E7EB"]
+  },
+  {
+    id: "ocean",
+    name: "Ocean",
+    description: "Cool blue tones",
+    colors: {
+      primary: "#0EA5E9",
+      background: "#F0F9FF",
+      text: "#0C4A6E",
+      subtext: "#0369A1",
+      border: "#BAE6FD",
+      button: "#0EA5E9"
+    },
+    radius: 16,
+    fontFamily: JAKARTA,
+    swatches: ["#0EA5E9", "#0C4A6E", "#BAE6FD"]
+  },
+  {
+    id: "sunset",
+    name: "Sunset",
+    description: "Warm orange glow",
+    colors: {
+      primary: "#F97316",
+      background: "#FFF7ED",
+      text: "#7C2D12",
+      subtext: "#C2410C",
+      border: "#FED7AA",
+      button: "#F97316"
+    },
+    radius: 16,
+    fontFamily: JAKARTA,
+    swatches: ["#F97316", "#7C2D12", "#FED7AA"]
+  },
+  {
+    id: "forest",
+    name: "Forest",
+    description: "Natural green hues",
+    colors: {
+      primary: "#16A34A",
+      background: "#F0FDF4",
+      text: "#14532D",
+      subtext: "#166534",
+      border: "#BBF7D0",
+      button: "#16A34A"
+    },
+    radius: 16,
+    fontFamily: JAKARTA,
+    swatches: ["#16A34A", "#14532D", "#BBF7D0"]
+  },
+  {
+    id: "midnight",
+    name: "Midnight",
+    description: "Deep dark mode",
+    colors: {
+      primary: "#A78BFA",
+      background: "#0F172A",
+      text: "#F8FAFC",
+      subtext: "#94A3B8",
+      border: "#1E293B",
+      button: "#A78BFA"
+    },
+    radius: 16,
+    fontFamily: JAKARTA,
+    swatches: ["#A78BFA", "#0F172A", "#1E293B"]
+  },
+  {
+    id: "candy",
+    name: "Candy",
+    description: "Playful pink + violet",
+    colors: {
+      primary: "#EC4899",
+      background: "#FDF2F8",
+      text: "#831843",
+      subtext: "#BE185D",
+      border: "#FBCFE8",
+      button: "#EC4899"
+    },
+    radius: 20,
+    fontFamily: JAKARTA,
+    swatches: ["#EC4899", "#831843", "#FBCFE8"]
+  },
+  {
+    id: "mono",
+    name: "Mono",
+    description: "High-contrast B&W",
+    colors: {
+      primary: "#000000",
+      background: "#FFFFFF",
+      text: "#000000",
+      subtext: "#525252",
+      border: "#000000",
+      button: "#000000"
+    },
+    radius: 4,
+    fontFamily: JAKARTA,
+    swatches: ["#000000", "#FFFFFF", "#525252"]
+  },
+  {
+    id: "coral",
+    name: "Coral",
+    description: "Soft coral accent",
+    colors: {
+      primary: "#FB7185",
+      background: "#FFF1F2",
+      text: "#881337",
+      subtext: "#9F1239",
+      border: "#FECDD3",
+      button: "#FB7185"
+    },
+    radius: 16,
+    fontFamily: JAKARTA,
+    swatches: ["#FB7185", "#881337", "#FECDD3"]
+  },
+  {
+    id: "ink",
+    name: "Ink",
+    description: "Deep navy editorial",
+    colors: {
+      primary: "#1E3A8A",
+      background: "#F8FAFC",
+      text: "#0F172A",
+      subtext: "#475569",
+      border: "#CBD5E1",
+      button: "#1E3A8A"
+    },
+    radius: 12,
+    fontFamily: JAKARTA,
+    swatches: ["#1E3A8A", "#0F172A", "#CBD5E1"]
+  },
+  {
+    id: "mint",
+    name: "Mint",
+    description: "Fresh teal vibe",
+    colors: {
+      primary: "#14B8A6",
+      background: "#F0FDFA",
+      text: "#134E4A",
+      subtext: "#0F766E",
+      border: "#99F6E4",
+      button: "#14B8A6"
+    },
+    radius: 16,
+    fontFamily: JAKARTA,
+    swatches: ["#14B8A6", "#134E4A", "#99F6E4"]
+  },
+  {
+    id: "slate",
+    name: "Slate",
+    description: "Quiet professional",
+    colors: {
+      primary: "#475569",
+      background: "#F1F5F9",
+      text: "#0F172A",
+      subtext: "#64748B",
+      border: "#CBD5E1",
+      button: "#475569"
+    },
+    radius: 12,
+    fontFamily: JAKARTA,
+    swatches: ["#475569", "#0F172A", "#CBD5E1"]
+  },
+  {
+    id: "aurora",
+    name: "Aurora",
+    description: "Vibrant gradient pop",
+    colors: {
+      primary: "#8B5CF6",
+      background: "#FAF5FF",
+      text: "#3B0764",
+      subtext: "#7E22CE",
+      border: "#E9D5FF",
+      accent: "#EC4899",
+      button: "#8B5CF6"
+    },
+    radius: 20,
+    fontFamily: JAKARTA,
+    swatches: ["#8B5CF6", "#EC4899", "#E9D5FF"]
+  }
+];
+function getThemePresetById(id2) {
+  return THEME_PRESETS.find((preset) => preset.id === id2);
+}
+function defaultThemePreset() {
+  return THEME_PRESETS[0];
+}
+
+// src/types/brand.ts
+function brandTokensFromPreset(preset) {
+  return {
+    colors: {
+      primary: preset.colors.primary,
+      background: preset.colors.background,
+      text: preset.colors.text,
+      subtext: preset.colors.subtext,
+      border: preset.colors.border
+    },
+    radius: preset.radius,
+    fontFamily: preset.fontFamily
+  };
+}
+function promptThemeFromBrandTokens(tokens) {
+  return {
+    colors: { ...tokens.colors },
+    radius: tokens.radius,
+    fontFamily: tokens.fontFamily
+  };
+}
+function inAppColorsFromBrandTokens(tokens) {
+  return {
+    backgroundColor: tokens.colors.background,
+    accentColor: tokens.colors.primary
+  };
+}
+function requestAccentFromBrandTokens(tokens) {
+  return tokens.colors.primary;
+}
+
+// src/types/integration.ts
+var INTEGRATION_PROVIDERS = ["amplitude", "mixpanel"];
+var INTEGRATION_CATEGORIES = [
+  "feedback",
+  "surveys",
+  "inapp",
+  "push",
+  "requests",
+  "lifecycle"
+];
+var USER_IDENTIFIED_EVENT_NAME = "$user_identified";
+function camelize(value) {
+  return value.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
+}
+var ids = (...keys) => Object.fromEntries(keys.map((key2) => [key2, [key2, camelize(key2)]]));
+var pushEvents = [
+  ["$push_sent", "UserGist Push Sent"],
+  ["$push_delivered", "UserGist Push Delivered"],
+  ["$push_received", "UserGist Push Received"],
+  ["$push_displayed", "UserGist Push Displayed"],
+  ["$push_opened", "UserGist Push Opened"],
+  ["$push_dismissed", "UserGist Push Dismissed"],
+  ["$push_clicked", "UserGist Push Clicked"],
+  ["$push_action_clicked", "UserGist Push Action Clicked"],
+  ["$push_bounced", "UserGist Push Bounced"]
+];
+var requestEvents = [
+  ["$request_submitted", "UserGist Request Submitted", "actor"],
+  ["$request_upvoted", "UserGist Request Upvoted", "actor"],
+  ["$request_unupvoted", "UserGist Request Unupvoted", "actor"],
+  ["$request_followed", "UserGist Request Followed", "actor"],
+  ["$request_unfollowed", "UserGist Request Unfollowed", "actor"],
+  ["$request_status_changed", "UserGist Request Status Changed", "affected_user"],
+  ["$request_responded", "UserGist Request Responded", "affected_user"],
+  ["$request_commented", "UserGist Request Commented", "actor"],
+  ["$request_comment_edited", "UserGist Request Comment Edited", "actor"],
+  ["$request_comment_deleted", "UserGist Request Comment Deleted", "affected_user"]
+];
+var answerProperties = {
+  ...ids(
+    "question_id",
+    "question_type",
+    "question_title",
+    "answer_format",
+    "answer_present",
+    "answer_numeric_value",
+    "answer_selection_count",
+    "answer_text_length"
+  ),
+  // These aliases are generated only by the trusted server response paths.
+  // The API delivery boundary removes them from public SDK events before this
+  // normalizer runs. The complete answer_value stays in UserGist; destinations
+  // receive a value only for server-verified structured data.
+  answer_value: ["__usergist_destination_answer_value"],
+  answer_display_value: ["__usergist_destination_answer_display_value"]
+};
+var CORE_INTEGRATION_EVENTS = [
+  { key: "$app_open", name: "UserGist App Opened", category: "lifecycle", subjectRole: "actor", properties: {} },
+  { key: "$app_version_changed", name: "UserGist App Version Changed", category: "lifecycle", subjectRole: "actor", properties: { ...ids("old_version", "new_version") } },
+  { key: USER_IDENTIFIED_EVENT_NAME, name: "UserGist User Identified", category: "identity", subjectRole: "actor", required: true, properties: {} },
+  { key: "$feedback_prompt_shown", name: "UserGist Feedback Prompt Shown", category: "feedback", subjectRole: "actor", properties: { ...ids("prompt_id") } },
+  { key: "$feedback_response", name: "UserGist Feedback Response Submitted", category: "feedback", subjectRole: "actor", properties: { ...ids("response_id", "prompt_id", "prompt_name", "dismissed", "latency_ms", "answer_count", "feedback_types") } },
+  { key: "$feedback_answer_submitted", name: "UserGist Feedback Answer Submitted", category: "feedback", subjectRole: "actor", properties: { ...ids("response_id", "prompt_id", "prompt_name"), ...answerProperties } },
+  { key: "$survey_started", name: "UserGist Survey Started", category: "surveys", subjectRole: "actor", properties: { ...ids("campaign_id", "survey_name", "attempt_id", "language", "source") } },
+  { key: "$survey_answer_submitted", name: "UserGist Survey Answer Submitted", category: "surveys", subjectRole: "actor", properties: { ...ids("response_id", "campaign_id", "survey_name", "attempt_id", "language"), ...answerProperties } },
+  { key: "$survey_completed", name: "UserGist Survey Completed", category: "surveys", subjectRole: "actor", properties: { ...ids("campaign_id", "survey_name", "attempt_id", "language", "source", "duration_ms") } },
+  { key: "$survey_abandoned", name: "UserGist Survey Abandoned", category: "surveys", subjectRole: "actor", properties: { ...ids("campaign_id", "survey_name", "attempt_id", "language", "source", "duration_ms") } },
+  { key: "$inapp_shown", name: "UserGist In-App Message Shown", category: "inapp", subjectRole: "actor", properties: { ...ids("message_id") } },
+  { key: "$inapp_dismissed", name: "UserGist In-App Message Dismissed", category: "inapp", subjectRole: "actor", properties: { ...ids("message_id", "dismiss_reason") } },
+  { key: "$inapp_auto_dismissed", name: "UserGist In-App Message Auto-Dismissed", category: "inapp", subjectRole: "actor", properties: { ...ids("message_id", "dismiss_reason") } },
+  { key: "$inapp_cta_clicked", name: "UserGist In-App Message CTA Clicked", category: "inapp", subjectRole: "actor", properties: { ...ids("message_id", "cta_id", "cta_index"), action: ["action", "cta_action"] } },
+  ...pushEvents.map(([key2, name]) => ({
+    key: key2,
+    name,
+    category: "push",
+    subjectRole: "actor",
+    properties: {
+      ...ids("delivery_id", "campaign_id", "delivery_state", "failure_code"),
+      action_id: ["action_id", "actionId", "action_button", "actionButton"]
+    }
+  })),
+  ...requestEvents.map(([key2, name, subjectRole]) => ({ key: key2, name, category: "requests", subjectRole, properties: { ...ids("request_id", "comment_id", "source", "old_status", "new_status", "deleted_by"), usergist_actor_type: ["usergist_actor_type", "actor_type"] } }))
+];
+var CORE_EVENT_BY_KEY = new Map(CORE_INTEGRATION_EVENTS.map((event) => [event.key, event]));
+function getCoreIntegrationEvent(key2) {
+  return CORE_EVENT_BY_KEY.get(key2) ?? null;
+}
+function sanitizeCoreIntegrationProperties(definition, input) {
+  if (!input) return {};
+  const output = {};
+  for (const [outputKey, aliases] of Object.entries(definition.properties)) {
+    const alias = aliases.find((candidate) => Object.prototype.hasOwnProperty.call(input, candidate));
+    if (!alias) continue;
+    const value = input[alias];
+    if (typeof value === "string") output[outputKey] = value.slice(0, 1024);
+    else if (typeof value === "number" && Number.isFinite(value)) output[outputKey] = value;
+    else if (typeof value === "boolean" || value === null) output[outputKey] = value;
+  }
+  return output;
+}
+
+// src/constants/push-events.ts
+var PUSH_EVENTS = {
+  SENT: "$push_sent",
+  DELIVERED: "$push_delivered",
+  DISPLAYED: "$push_displayed",
+  RECEIVED: "$push_received",
+  OPENED: "$push_opened",
+  DISMISSED: "$push_dismissed",
+  CLICKED: "$push_clicked",
+  ACTION_CLICKED: "$push_action_clicked",
+  BOUNCED: "$push_bounced",
+  SILENT_ACK: "$push_silent_ack"
+};
+
+// src/types/push-runtime.ts
+function isSilentPushPayload(raw) {
+  if (!raw) return false;
+  return raw.usergist_silent === "1" && typeof raw.usergist_ping_id === "string";
+}
+
+// src/evaluate/segment.ts
+function evaluateSegment(dsl, user, now = Date.now()) {
+  return evaluateGroup(dsl.root, user, now);
+}
+function evaluateGroup(group, user, now) {
+  if (group.predicates.length === 0) return true;
+  if (group.combinator === "AND") {
+    return group.predicates.every((p) => evaluateNode(p, user, now));
+  }
+  return group.predicates.some((p) => evaluateNode(p, user, now));
+}
+function evaluateNode(node, user, now) {
+  if ("combinator" in node) return evaluateGroup(node, user, now);
+  switch (node.kind) {
+    case "user_property":
+      return evaluateUserProperty(node, user);
+    case "event_count":
+      return evaluateEventCount(node, user);
+    case "event_occurred":
+      return evaluateEventOccurred(node, user, now);
+  }
+}
+function evaluateUserProperty(p, user) {
+  const actual = user.properties[p.key];
+  switch (p.op) {
+    case "exists":
+      return actual !== void 0 && actual !== null;
+    case "not_exists":
+      return actual === void 0 || actual === null;
+    case "eq":
+      return actual === p.value;
+    case "neq":
+      return actual !== p.value;
+    case "in":
+      return Array.isArray(p.value) && actual != null && p.value.includes(actual);
+    case "nin":
+      return Array.isArray(p.value) && actual != null && !p.value.includes(actual);
+    case "gt":
+      return typeof actual === "number" && typeof p.value === "number" && actual > p.value;
+    case "gte":
+      return typeof actual === "number" && typeof p.value === "number" && actual >= p.value;
+    case "lt":
+      return typeof actual === "number" && typeof p.value === "number" && actual < p.value;
+    case "lte":
+      return typeof actual === "number" && typeof p.value === "number" && actual <= p.value;
+    case "contains":
+      return typeof actual === "string" && typeof p.value === "string" && actual.includes(p.value);
+    case "starts_with":
+      return typeof actual === "string" && typeof p.value === "string" && actual.startsWith(p.value);
+  }
+}
+function evaluateEventCount(p, user) {
+  const eventBucket = user.eventCounts[p.eventName];
+  const count = eventBucket?.[p.windowDays] ?? 0;
+  switch (p.op) {
+    case "eq":
+      return count === p.count;
+    case "gte":
+      return count >= p.count;
+    case "lte":
+      return count <= p.count;
+    case "gt":
+      return count > p.count;
+    case "lt":
+      return count < p.count;
+  }
+}
+function evaluateEventOccurred(p, user, now) {
+  const last = user.lastEventAt[p.eventName];
+  if (p.ever) {
+    if (!last) return false;
+    if (p.windowDays == null) return true;
+    const cutoff2 = now - p.windowDays * 864e5;
+    return Date.parse(last) >= cutoff2;
+  }
+  if (!last) return true;
+  if (p.windowDays == null) return false;
+  const cutoff = now - p.windowDays * 864e5;
+  return Date.parse(last) < cutoff;
+}
+function evaluateSerializedSegmentRules(rules, user, now = Date.now()) {
+  if (!rules) return true;
+  const dsl = serializedRulesToDsl(rules);
+  return evaluateSegment(dsl, user, now);
+}
+function serializedRulesToDsl(rules) {
+  const predicates = [];
+  for (const rule of rules.userProperties ?? []) {
+    predicates.push(userPropertyRuleToPredicate(rule));
+  }
+  for (const rule of rules.eventCounts ?? []) {
+    predicates.push({
+      kind: "event_count",
+      eventName: rule.eventName,
+      op: rule.op,
+      count: rule.count,
+      windowDays: rule.windowDays
+    });
+  }
+  return {
+    version: 1,
+    root: { combinator: "AND", predicates }
+  };
+}
+function userPropertyRuleToPredicate(rule) {
+  return {
+    kind: "user_property",
+    key: rule.key,
+    op: rule.op,
+    value: rule.value
+  };
+}
+
+// src/evaluate/branch.ts
+function evaluateBranchCondition(cond, answer) {
+  if (cond.op === "answered") return answer !== void 0 && answer !== null && answer !== "";
+  if (cond.op === "unanswered") return answer === void 0 || answer === null || answer === "";
+  if (answer === void 0 || answer === null) return false;
+  switch (cond.op) {
+    case "eq":
+      return answer === cond.value;
+    case "neq":
+      return answer !== cond.value;
+    case "lt":
+      return typeof answer === "number" && typeof cond.value === "number" && answer < cond.value;
+    case "lte":
+      return typeof answer === "number" && typeof cond.value === "number" && answer <= cond.value;
+    case "gt":
+      return typeof answer === "number" && typeof cond.value === "number" && answer > cond.value;
+    case "gte":
+      return typeof answer === "number" && typeof cond.value === "number" && answer >= cond.value;
+    case "includes":
+      return Array.isArray(answer) && answer.includes(cond.value);
+    case "not_includes":
+      return Array.isArray(answer) && !answer.includes(cond.value);
+    default:
+      return false;
+  }
+}
+function nextQuestionId(flow, currentQuestionId, answers) {
+  const branches = flow.branches.filter((b) => b.fromQuestionId === currentQuestionId);
+  const answer = answers[currentQuestionId];
+  for (const branch of branches) {
+    if (evaluateBranchCondition(branch.condition, answer)) {
+      if (branch.toQuestionId === SURVEY_END_SENTINEL) return null;
+      return branch.toQuestionId;
+    }
+  }
+  return defaultNext(flow, currentQuestionId);
+}
+function defaultNext(flow, currentQuestionId) {
+  const idx = flow.questions.findIndex((q) => q.id === currentQuestionId);
+  if (idx < 0 || idx >= flow.questions.length - 1) return null;
+  const next = flow.questions[idx + 1];
+  return next ? next.id : null;
+}
+function findQuestion(flow, questionId) {
+  return flow.questions.find((q) => q.id === questionId);
+}
+function findQuestionIndex(flow, questionId) {
+  return flow.questions.findIndex((q) => q.id === questionId);
+}
+function estimateProgress(flow, currentQuestionId) {
+  if (!currentQuestionId) return 1;
+  const idx = findQuestionIndex(flow, currentQuestionId);
+  if (idx < 0) return 0;
+  return (idx + 1) / Math.max(1, flow.questions.length);
+}
+function reachableQuestions(flow, startId) {
+  const start = startId ?? flow.startQuestionId;
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [start];
+  while (stack.length > 0) {
+    const id2 = stack.pop();
+    if (id2 === void 0) continue;
+    if (visited.has(id2)) continue;
+    visited.add(id2);
+    const outgoing = flow.branches.filter((b) => b.fromQuestionId === id2);
+    for (const b of outgoing) {
+      if (b.toQuestionId !== SURVEY_END_SENTINEL) stack.push(b.toQuestionId);
+    }
+    const idx = flow.questions.findIndex((q) => q.id === id2);
+    if (idx >= 0 && idx < flow.questions.length - 1) {
+      const next = flow.questions[idx + 1];
+      if (next) stack.push(next.id);
+    }
+  }
+  return visited;
+}
+
+// src/evaluate/periodic.ts
+function nextPeriodicFire(schedule, now = /* @__PURE__ */ new Date()) {
+  const tz = schedule.tz || "UTC";
+  const start = startCandidate(schedule, now, tz);
+  return walkForward(start, schedule, now, tz);
+}
+function tzOffsetMinutes(at, tz) {
+  if (tz === "UTC") return 0;
+  try {
+    const fmt = getFormatter(tz);
+    const parts = fmt.formatToParts(at).reduce((acc, p) => {
+      if (p.type !== "literal") acc[p.type] = p.value;
+      return acc;
+    }, {});
+    const utc = Date.UTC(
+      Number(parts.year),
+      Number(parts.month) - 1,
+      Number(parts.day),
+      Number(parts.hour) === 24 ? 0 : Number(parts.hour),
+      Number(parts.minute),
+      Number(parts.second)
+    );
+    return Math.round((utc - at.getTime()) / 6e4);
+  } catch {
+    return 0;
+  }
+}
+function startCandidate(schedule, now, tz) {
+  const localNow = wallClock(now, tz);
+  const target = new Date(localNow);
+  target.setUTCHours(schedule.hourLocal, schedule.minuteLocal, 0, 0);
+  return localToUtc(target, tz);
+}
+function walkForward(candidate, schedule, now, tz) {
+  let cursor = candidate;
+  const max = schedule.frequency === "daily" ? 2 : schedule.frequency === "weekly" ? 8 : 13;
+  for (let i = 0; i < max; i++) {
+    const local = wallClock(cursor, tz);
+    if (matchesFrequency(local, schedule) && cursor.getTime() > now.getTime()) {
+      return cursor;
+    }
+    cursor = step(cursor, local, schedule, tz);
+  }
+  return cursor;
+}
+function matchesFrequency(local, schedule) {
+  if (schedule.frequency === "daily") return true;
+  if (schedule.frequency === "weekly") {
+    return schedule.weekday === void 0 || local.getUTCDay() === schedule.weekday;
+  }
+  return schedule.dayOfMonth === void 0 || local.getUTCDate() === schedule.dayOfMonth;
+}
+function step(cursor, cursorLocal, schedule, tz) {
+  if (schedule.frequency === "daily" || schedule.frequency === "weekly") {
+    return addDays(cursor, 1);
+  }
+  const next = new Date(cursorLocal);
+  next.setUTCMonth(next.getUTCMonth() + 1);
+  if (schedule.dayOfMonth !== void 0) {
+    const lastDay = lastDayOfMonth(next.getUTCFullYear(), next.getUTCMonth());
+    next.setUTCDate(Math.min(schedule.dayOfMonth, lastDay));
+  }
+  next.setUTCHours(schedule.hourLocal, schedule.minuteLocal, 0, 0);
+  return localToUtc(next, tz);
+}
+function addDays(d, days) {
+  const next = new Date(d.getTime());
+  next.setUTCDate(next.getUTCDate() + days);
+  return next;
+}
+function lastDayOfMonth(year, monthIndex) {
+  return new Date(Date.UTC(year, monthIndex + 1, 0)).getUTCDate();
+}
+function wallClock(d, tz) {
+  const offsetMin = tzOffsetMinutes(d, tz);
+  return new Date(d.getTime() + offsetMin * 6e4);
+}
+function localToUtc(localView, tz) {
+  const offsetMin = tzOffsetMinutes(localView, tz);
+  return new Date(localView.getTime() - offsetMin * 6e4);
+}
+var FORMATTER_CACHE = /* @__PURE__ */ new Map();
+function getFormatter(tz) {
+  const cached = FORMATTER_CACHE.get(tz);
+  if (cached) return cached;
+  const fmt = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  FORMATTER_CACHE.set(tz, fmt);
+  return fmt;
+}
+
+// src/types/web.ts
+var DELIVERY_PROTOCOL_VERSION = 2;
+function deliveryPlatformsForApp(platforms) {
+  const values = /* @__PURE__ */ new Set();
+  for (const platform of platforms) {
+    if (platform === "web" || platform === "ios" || platform === "android") values.add(platform);
+    if (platform === "expo" || platform === "react-native" || platform === "flutter") {
+      values.add("ios");
+      values.add("android");
+    }
+  }
+  return [...values];
+}
+function resolveWebPresentation(pillar, override) {
+  return {
+    layout: override?.layout ?? "modal",
+    size: override?.size ?? (pillar === "requests" ? "wide" : "standard"),
+    position: override?.position ?? "right",
+    backdrop: override?.backdrop ?? override?.layout !== "card"
+  };
+}
+var id = z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/);
+var key = z.string().min(1).max(120).refine(
+  (v) => !["__proto__", "prototype", "constructor"].includes(v),
+  "Reserved property key"
+);
+var scalar = z.union([
+  z.string().max(8192),
+  z.number().finite(),
+  z.boolean(),
+  z.null()
+]);
+var baseSource = { id, label: z.string().min(1).max(120) };
+var filterSchema = z.object({
+  key,
+  op: z.enum([
+    "eq",
+    "neq",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "in",
+    "nin",
+    "contains",
+    "starts_with",
+    "exists",
+    "not_exists"
+  ]),
+  value: z.union([
+    z.string(),
+    z.number().finite(),
+    z.boolean(),
+    z.array(z.union([z.string(), z.number().finite()])).max(100)
+  ]).optional()
+});
+var personalizationSpecSchema = z.object({
+  version: z.literal(1),
+  sources: z.array(
+    z.discriminatedUnion("kind", [
+      z.object({ ...baseSource, kind: z.literal("user_property") }),
+      z.object({ ...baseSource, kind: z.literal("trigger_event") }),
+      z.object({ ...baseSource, kind: z.literal("send_data") }),
+      z.object({ ...baseSource, kind: z.literal("app") }),
+      z.object({ ...baseSource, kind: z.literal("now") }),
+      z.object({
+        ...baseSource,
+        kind: z.literal("latest_event"),
+        eventName: z.string().min(1).max(120),
+        lookbackDays: z.number().int().min(1).max(90),
+        filters: z.array(filterSchema).max(8).optional()
+      })
+    ])
+  ).max(16),
+  bindings: z.array(
+    z.object({
+      id,
+      label: z.string().min(1).max(120),
+      sourceId: id,
+      key,
+      type: z.enum(["string", "number", "boolean", "date"]),
+      fallback: scalar.optional()
+    })
+  ).max(64),
+  missingData: z.literal("skip")
+}).superRefine((spec, ctx) => {
+  const sources = new Set(spec.sources.map((source) => source.id));
+  if (sources.size !== spec.sources.length)
+    ctx.addIssue({
+      code: "custom",
+      path: ["sources"],
+      message: "Source IDs must be unique"
+    });
+  if (spec.sources.filter((source) => source.kind === "latest_event").length > 4)
+    ctx.addIssue({
+      code: "custom",
+      path: ["sources"],
+      message: "Use at most four activity sources"
+    });
+  const bindings = /* @__PURE__ */ new Set();
+  spec.bindings.forEach((binding, index) => {
+    if (bindings.has(binding.id))
+      ctx.addIssue({
+        code: "custom",
+        path: ["bindings", index, "id"],
+        message: "Field IDs must be unique"
+      });
+    bindings.add(binding.id);
+    if (!sources.has(binding.sourceId))
+      ctx.addIssue({
+        code: "custom",
+        path: ["bindings", index, "sourceId"],
+        message: "Choose an existing source"
+      });
+    if (binding.fallback !== void 0 && (isMissing(binding.fallback) || !matchesType(binding.fallback, binding.type)))
+      ctx.addIssue({
+        code: "custom",
+        path: ["bindings", index, "fallback"],
+        message: "Fallback must be a non-empty value of the selected type"
+      });
+  });
+});
+var userPropertiesUpdateSchema = z.object({
+  mutationId: z.string().uuid(),
+  set: z.record(key, scalar).refine(
+    (v) => Object.keys(v).length <= 64,
+    "Update at most 64 properties"
+  ).optional(),
+  unset: z.array(key).max(64).optional()
+}).superRefine((update, ctx) => {
+  if (!Object.keys(update.set ?? {}).length && !update.unset?.length)
+    ctx.addIssue({
+      code: "custom",
+      message: "Supply properties to set or remove"
+    });
+  if (update.unset?.some((name) => Object.hasOwn(update.set ?? {}, name)))
+    ctx.addIssue({
+      code: "custom",
+      message: "A property cannot be set and removed in the same update"
+    });
+});
+function isMissing(value) {
+  return value == null || typeof value === "string" && !value.trim();
+}
+function matchesType(value, type) {
+  if (type === "date")
+    return typeof value === "string" && !Number.isNaN(Date.parse(value));
+  return typeof value === type && (typeof value !== "number" || Number.isFinite(value));
+}
+function resolvePersonalizationBindings(spec, sources) {
+  const values = /* @__PURE__ */ Object.create(null);
+  const issues = [];
+  const fallbackBindingIds = [];
+  for (const binding of spec.bindings) {
+    const source = sources[binding.sourceId]?.values;
+    const value = source && Object.hasOwn(source, binding.key) ? source[binding.key] : void 0;
+    const missing = isMissing(value);
+    if (!missing && matchesType(value, binding.type))
+      values[binding.id] = value;
+    else if (missing && binding.fallback !== void 0) {
+      values[binding.id] = binding.fallback;
+      fallbackBindingIds.push(binding.id);
+    } else
+      issues.push({
+        code: missing ? "missing" : "type_mismatch",
+        bindingId: binding.id,
+        message: missing ? `${binding.label} is missing` : `${binding.label} must be ${binding.type}`
+      });
+  }
+  return {
+    status: issues.length ? "skipped" : fallbackBindingIds.length ? "using_fallback" : "ready",
+    values,
+    fallbackBindingIds,
+    issues,
+    sources
+  };
+}
+var TOKEN = /\{\{\s*p\.([A-Za-z][A-Za-z0-9_]*)\s*\}\}/g;
+var WHOLE_TOKEN = /^\{\{\s*p\.([A-Za-z][A-Za-z0-9_]*)\s*\}\}$/;
+function personalizationToken(bindingId) {
+  return `{{p.${bindingId}}}`;
+}
+function renderPersonalizedValue(input, values, issues, path = "", mode = "text") {
+  if (typeof input === "string") {
+    const whole = WHOLE_TOKEN.exec(input);
+    const lookup = (bindingId) => {
+      if (Object.hasOwn(values, bindingId)) return values[bindingId];
+      issues.push({
+        code: "unknown_binding",
+        bindingId,
+        path,
+        message: `No value is available for ${bindingId}`
+      });
+      return null;
+    };
+    if (mode === "json" && whole) return lookup(whole[1]);
+    if (/\{\{|\}\}/.test(input.replace(TOKEN, "")))
+      issues.push({
+        code: "invalid_template",
+        path,
+        message: "Insert a valid dynamic field"
+      });
+    const result = input.replace(TOKEN, (_, bindingId) => {
+      const value = lookup(bindingId);
+      return mode === "url" && !whole ? encodeURIComponent(String(value ?? "")) : String(value ?? "");
+    });
+    if (mode === "url" && result) {
+      try {
+        const url = new URL(result);
+        if (["javascript:", "data:", "file:", "vbscript:"].includes(url.protocol))
+          throw new Error("unsafe");
+        if (!whole && /\{\{/.test(input.split(/:\/\//)[0] ?? ""))
+          throw new Error("dynamic scheme");
+        if (!whole && /\{\{/.test(
+          input.match(/^[a-z][a-z0-9+.-]*:\/\/([^/?#]*)/i)?.[1] ?? ""
+        ))
+          throw new Error("dynamic authority");
+      } catch {
+        issues.push({
+          code: "invalid_destination",
+          path,
+          message: "The resolved destination must be a valid app link or web URL"
+        });
+      }
+    }
+    return result;
+  }
+  if (Array.isArray(input))
+    return input.map(
+      (item, index) => renderPersonalizedValue(item, values, issues, `${path}/${index}`, mode)
+    );
+  if (input && typeof input === "object") {
+    const result = /* @__PURE__ */ Object.create(null);
+    for (const [name, value] of Object.entries(input)) {
+      if (["__proto__", "constructor", "prototype"].includes(name)) {
+        issues.push({
+          code: "invalid_template",
+          path,
+          message: "Reserved object key"
+        });
+        continue;
+      }
+      result[name] = renderPersonalizedValue(
+        value,
+        values,
+        issues,
+        `${path}/${name}`,
+        mode
+      );
+    }
+    return result;
+  }
+  return input;
+}
+var TEXT_KEYS = /* @__PURE__ */ new Set([
+  "title",
+  "body",
+  "subtitle",
+  "headline",
+  "label",
+  "placeholder",
+  "followUp",
+  "lowLabel",
+  "highLabel",
+  "description",
+  "buttonText",
+  "submitLabel",
+  "nextLabel",
+  "backLabel",
+  "text"
+]);
+var URL_KEYS = /* @__PURE__ */ new Set(["imageUrl", "deepLink", "target"]);
+var CONTENT_KEYS = /* @__PURE__ */ new Set([
+  "questions",
+  "options",
+  "ctas",
+  "cta",
+  "actionButtons",
+  "flow",
+  "welcome",
+  "thankYou",
+  "completion",
+  "endScreen",
+  "openAction"
+]);
+function personalizationUsage(content) {
+  const usage = /* @__PURE__ */ new Map();
+  const scan = (value, field) => {
+    if (typeof value === "string") {
+      for (const match of value.matchAll(TOKEN)) {
+        const fields = usage.get(match[1]) ?? /* @__PURE__ */ new Set();
+        fields.add(field);
+        usage.set(match[1], fields);
+      }
+    } else if (Array.isArray(value)) value.forEach((item) => scan(item, field));
+    else if (value && typeof value === "object")
+      Object.values(value).forEach((item) => scan(item, field));
+  };
+  const walk = (value) => {
+    if (Array.isArray(value)) {
+      value.forEach(walk);
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    for (const [key2, item] of Object.entries(value)) {
+      if (TEXT_KEYS.has(key2) || URL_KEYS.has(key2) || key2 === "actionJson" || key2 === "payloadExtras")
+        scan(item, key2);
+      else if (CONTENT_KEYS.has(key2)) walk(item);
+    }
+  };
+  walk(content);
+  return usage;
+}
+function renderPersonalizedContent(content, resolution) {
+  const usage = personalizationUsage(content);
+  const onlyOptionalImage = (id2) => usage.get(id2)?.size === 1 && usage.get(id2)?.has("imageUrl");
+  const issues = resolution.issues.filter(
+    (issue) => !issue.bindingId || usage.has(issue.bindingId) && !(issue.code === "missing" && onlyOptionalImage(issue.bindingId))
+  );
+  const fallbacks = resolution.fallbackBindingIds.filter((id2) => usage.has(id2));
+  const walk = (value, path = "") => {
+    if (Array.isArray(value))
+      return value.map((item, index) => walk(item, `${path}/${index}`));
+    if (!value || typeof value !== "object") return value;
+    return Object.fromEntries(
+      Object.entries(value).map(([name, item]) => {
+        const childPath = `${path}/${name}`;
+        if (TEXT_KEYS.has(name) && typeof item === "string")
+          return [
+            name,
+            renderPersonalizedValue(item, resolution.values, issues, childPath)
+          ];
+        if (URL_KEYS.has(name) && typeof item === "string") {
+          if (name === "imageUrl" && [...item.matchAll(TOKEN)].some(
+            (match) => resolution.issues.some(
+              (issue) => issue.bindingId === match[1] && issue.code === "missing"
+            )
+          ))
+            return [name, null];
+          const isEvent = name === "target" && value.action === "custom_event";
+          const rendered2 = renderPersonalizedValue(
+            item,
+            resolution.values,
+            issues,
+            childPath,
+            isEvent ? "text" : "url"
+          );
+          if (name === "imageUrl" && rendered2 && !String(rendered2).startsWith("https://"))
+            issues.push({
+              code: "invalid_destination",
+              path: childPath,
+              message: "Image URLs must use HTTPS"
+            });
+          return [name, rendered2];
+        }
+        if (name === "actionJson" || name === "payloadExtras")
+          return [
+            name,
+            renderPersonalizedValue(
+              item,
+              resolution.values,
+              issues,
+              childPath,
+              "json"
+            )
+          ];
+        if (CONTENT_KEYS.has(name)) return [name, walk(item, childPath)];
+        return [name, item];
+      })
+    );
+  };
+  const rendered = walk(content);
+  return {
+    content: rendered,
+    resolution: {
+      ...resolution,
+      fallbackBindingIds: fallbacks,
+      status: issues.length ? "skipped" : fallbacks.length ? "using_fallback" : "ready",
+      issues
+    }
+  };
+}
+
+// src/presentation.ts
+var PresentationGate = class {
+  paused;
+  identity = 0;
+  revisions = { feedback: 0, survey: 0 };
+  listeners = /* @__PURE__ */ new Set();
+  constructor(paused = false) {
+    this.paused = paused;
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  setPaused(paused) {
+    this.paused = paused;
+    this.notify();
+  }
+  invalidate(purpose) {
+    if (purpose) this.revisions[purpose]++;
+    else this.identity++;
+    this.notify();
+  }
+  validator(purpose) {
+    const identity = this.identity;
+    const revision = this.revisions[purpose];
+    return () => identity === this.identity && revision === this.revisions[purpose];
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  runWhenReady(run, valid, cancel = () => {
+  }) {
+    if (!valid()) {
+      cancel();
+      return;
+    }
+    if (!this.paused) {
+      run();
+      return;
+    }
+    const stop = this.subscribe(() => {
+      if (valid() && this.paused) return;
+      stop();
+      if (valid()) run();
+      else cancel();
+    });
+  }
+  waitUntilReady(valid) {
+    if (!valid()) return Promise.resolve(false);
+    if (!this.paused) return Promise.resolve(true);
+    return new Promise((resolve) => {
+      const stop = this.subscribe(() => {
+        if (valid() && this.paused) return;
+        stop();
+        resolve(valid());
+      });
+    });
+  }
+  notify() {
+    for (const listener of [...this.listeners]) listener();
+  }
+};
+
+export { APP_OPEN_EVENT_NAME, APP_VERSION_CHANGED_EVENT_NAME, AUDIENCE_JOIN_EVENT_NAME, AUDIENCE_JOIN_TRIGGER_KIND, CORE_INTEGRATION_EVENTS, DELIVERY_PROTOCOL_VERSION, INAPP_AUTO_DISMISSED_EVENT_NAME, INAPP_CTA_CLICKED_EVENT_NAME, INAPP_DISMISSED_EVENT_NAME, INAPP_SHOWN_EVENT_NAME, INTEGRATION_CATEGORIES, INTEGRATION_PROVIDERS, PUSH_EVENTS, PresentationGate, RADIUS_PRESETS, REQUEST_COMMENTED_EVENT_NAME, REQUEST_COMMENT_DELETED_EVENT_NAME, REQUEST_COMMENT_EDITED_EVENT_NAME, REQUEST_FOLLOWED_EVENT_NAME, REQUEST_RESPONDED_EVENT_NAME, REQUEST_STATUS_CHANGED_EVENT_NAME, REQUEST_SUBMITTED_EVENT_NAME, REQUEST_UNFOLLOWED_EVENT_NAME, REQUEST_UNUPVOTED_EVENT_NAME, REQUEST_UPVOTED_EVENT_NAME, SURVEY_END_SENTINEL, THEME_PRESETS, USER_IDENTIFIED_EVENT_NAME, brandTokensFromPreset, defaultEventTrigger, defaultOnboardingMessage, defaultThemePreset, defaultTriggerSpec, deliveryPlatformsForApp, emptyAudienceSpec, emptySegmentDsl, err, estimateProgress, evaluateBranchCondition, evaluateSegment, evaluateSerializedSegmentRules, findQuestion, findQuestionIndex, getCoreIntegrationEvent, getThemePresetById, inAppColorsFromBrandTokens, isSilentPushPayload, nextPeriodicFire, nextQuestionId, ok, personalizationSpecSchema, personalizationToken, personalizationUsage, promptThemeFromBrandTokens, reachableQuestions, renderPersonalizedContent, renderPersonalizedValue, requestAccentFromBrandTokens, resolvePersonalizationBindings, resolveWebPresentation, sanitizeCoreIntegrationProperties, serializedRulesToDsl, tzOffsetMinutes, userPropertiesUpdateSchema };
+//# sourceMappingURL=client.js.map
+//# sourceMappingURL=client.js.map