impact-nova 2.2.8 → 2.3.0

package/dist/lib/guidance/engine/manifest-validator.js

@@ -0,0 +1,102 @@
+function a(t) {
+  return {
+    ...t,
+    title: c(t.title),
+    body: c(t.body),
+    footer: t.footer ? c(t.footer) : void 0,
+    media: t.media ? {
+      ...t.media,
+      src: l(t.media.src)
+    } : void 0,
+    actions: t.actions?.map((i) => ({
+      ...i,
+      label: c(i.label)
+    }))
+  };
+}
+function p(t) {
+  return {
+    ...t,
+    steps: t.steps.map((i) => ({
+      ...i,
+      content: a(i.content)
+    })),
+    locale: Object.fromEntries(
+      Object.entries(t.locale).map(([i, n]) => [
+        i,
+        n.map((r) => a(r))
+      ])
+    )
+  };
+}
+function c(t) {
+  return t.replace(/<[^>]*>/g, "").replace(/javascript:/gi, "").trim();
+}
+function l(t) {
+  if (t.startsWith("/") || t.startsWith("./"))
+    return t;
+  try {
+    const i = new URL(t);
+    if (i.protocol === "https:" || i.protocol === "http:")
+      return t;
+  } catch {
+    return "";
+  }
+  return "";
+}
+function f(t) {
+  const i = [];
+  t.schemaVersion !== 1 && i.push(`Unsupported schemaVersion: ${t.schemaVersion}`), t.id || i.push("Guide manifest requires id"), t.steps.length || i.push("Guide manifest requires at least one step");
+  const n = /* @__PURE__ */ new Set();
+  for (const r of t.steps)
+    n.has(r.id) && i.push(`Duplicate step id: ${r.id}`), n.add(r.id), (r.content.body.includes("<script") || r.content.body.includes("javascript:")) && i.push(`Step ${r.id} body contains disallowed content`);
+  if (t.transitions?.length) {
+    const r = d(t);
+    r && i.push(r);
+  }
+  for (const r of t.triggers) {
+    const s = u(r);
+    s && i.push(s);
+  }
+  return i;
+}
+function u(t) {
+  if ("op" in t) {
+    if (!t.conditions.length)
+      return `Trigger ${t.op} requires conditions`;
+    for (const i of t.conditions) {
+      const n = u(i);
+      if (n)
+        return n;
+    }
+    return null;
+  }
+  return t.plugin ? null : "Trigger plugin key is required";
+}
+function d(t) {
+  const i = /* @__PURE__ */ new Map();
+  for (const e of t.transitions ?? []) {
+    const o = i.get(e.from) ?? [];
+    o.push(e.to), i.set(e.from, o);
+  }
+  const n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), s = (e) => {
+    if (n.has(e))
+      return !0;
+    if (r.has(e))
+      return !1;
+    n.add(e);
+    for (const o of i.get(e) ?? [])
+      if (s(o))
+        return !0;
+    return n.delete(e), r.add(e), !1;
+  };
+  for (const e of t.steps)
+    if (s(e.id))
+      return "Guide transitions contain a cycle";
+  return null;
+}
+export {
+  p as sanitizeGuideManifest,
+  a as sanitizeStepContent,
+  f as validateGuideManifest
+};

package/dist/lib/guidance/engine/step-navigation.d.ts

@@ -0,0 +1,5 @@
+import { GuideManifest, Step, TriggerExpression } from '../types/guidance.types';
+export declare function getStepById(manifest: GuideManifest, stepId: string): Step | undefined;
+export declare function getStepIndex(manifest: GuideManifest, stepId: string): number;
+export declare function getNextStepId(manifest: GuideManifest, currentStepId: string, evaluateCondition: (expression: TriggerExpression) => Promise<boolean>): Promise<string | null>;
+export declare function resolveLocalizedStepContent(manifest: GuideManifest, step: Step, locale: string): Step['content'];

package/dist/lib/guidance/engine/step-navigation.js

@@ -0,0 +1,35 @@
+function a(t, e) {
+  return t.steps.find((n) => n.id === e);
+}
+function c(t, e) {
+  return t.steps.findIndex((n) => n.id === e);
+}
+function l(t, e, n) {
+  const o = (t.transitions ?? []).filter(
+    (r) => r.from === e
+  );
+  if (!o.length) {
+    const r = c(t, e), s = t.steps[r + 1];
+    return Promise.resolve(s?.id ?? null);
+  }
+  return u(o, n);
+}
+async function u(t, e) {
+  for (const n of t)
+    if (!n.condition || await e(n.condition))
+      return n.to;
+  return null;
+}
+function d(t, e, n) {
+  const i = t.locale[n], o = c(t, e.id);
+  if (i?.[o])
+    return i[o];
+  const r = n.split("-")[0], s = t.locale[r];
+  return s?.[o] ? s[o] : e.content;
+}
+export {
+  l as getNextStepId,
+  a as getStepById,
+  c as getStepIndex,
+  d as resolveLocalizedStepContent
+};

package/dist/lib/guidance/index.d.ts

@@ -0,0 +1,12 @@
+export * from './types/guidance.types';
+export { GuidanceEngine } from './engine/guidance-engine';
+export { GuideRegistry } from './engine/guide-registry';
+export { sanitizeGuideManifest, validateGuideManifest, } from './engine/manifest-validator';
+export { getNextStepId, getStepById, resolveLocalizedStepContent, } from './engine/step-navigation';
+export { TriggerPluginRegistry } from './triggers/trigger-registry';
+export { registerBuiltInTriggerPlugins } from './triggers/built-in-triggers';
+export { LocalStorageGuidanceAdapter, defaultGuidanceStorageAdapter, } from './storage/storage-adapter';
+export { buildGuidanceStorageKey, buildCampaignStorageKey, buildSessionStatsKey, } from './storage/storage-keys';
+export { NoopGuidanceAnalyticsAdapter, SamplingGuidanceAnalyticsAdapter, defaultGuidanceAnalyticsAdapter, } from './analytics/analytics-adapter';
+export { GuidanceTargetRefRegistry, globalGuidanceTargetRefRegistry, } from './targets/ref-registry';
+export { TargetResolver, waitForTargetResolved, waitForTargetVisible, resolveTargetSynchronously } from './targets/target-resolver';

package/dist/lib/guidance/storage/storage-adapter.d.ts

@@ -0,0 +1,10 @@
+import { GuidanceStorageAdapter } from '../types/guidance.types';
+export declare class LocalStorageGuidanceAdapter implements GuidanceStorageAdapter {
+    private readonly keyPrefix;
+    constructor(keyPrefix?: string);
+    get(keys: string[]): Promise<Record<string, unknown>>;
+    set(entries: Record<string, unknown>): Promise<void>;
+    delete(keys: string[]): Promise<void>;
+    erasure(): Promise<void>;
+}
+export declare const defaultGuidanceStorageAdapter: LocalStorageGuidanceAdapter;

package/dist/lib/guidance/storage/storage-adapter.js

@@ -0,0 +1,51 @@
+const r = "guidance:";
+class i {
+  keyPrefix;
+  constructor(t = r) {
+    this.keyPrefix = t;
+  }
+  async get(t) {
+    if (typeof window > "u")
+      return {};
+    const e = {};
+    for (const o of t) {
+      const n = window.localStorage.getItem(`${this.keyPrefix}${o}`);
+      if (n !== null)
+        try {
+          e[o] = JSON.parse(n);
+        } catch {
+          e[o] = n;
+        }
+    }
+    return e;
+  }
+  async set(t) {
+    if (!(typeof window > "u"))
+      for (const [e, o] of Object.entries(t))
+        window.localStorage.setItem(
+          `${this.keyPrefix}${e}`,
+          JSON.stringify(o)
+        );
+  }
+  async delete(t) {
+    if (!(typeof window > "u"))
+      for (const e of t)
+        window.localStorage.removeItem(`${this.keyPrefix}${e}`);
+  }
+  async erasure() {
+    if (typeof window > "u")
+      return;
+    const t = [];
+    for (let e = 0; e < window.localStorage.length; e += 1) {
+      const o = window.localStorage.key(e);
+      o?.startsWith(this.keyPrefix) && t.push(o);
+    }
+    for (const e of t)
+      window.localStorage.removeItem(e);
+  }
+}
+const s = new i();
+export {
+  i as LocalStorageGuidanceAdapter,
+  s as defaultGuidanceStorageAdapter
+};

package/dist/lib/guidance/storage/storage-keys.d.ts

@@ -0,0 +1,10 @@
+export declare function buildGuidanceStorageKey(tenantId: string, guideId: string, suffix: string): string;
+export declare function buildCampaignStorageKey(tenantId: string, campaignId: string): string;
+export declare function buildSessionStatsKey(tenantId: string): string;
+export interface SessionStats {
+    guidesShownThisSession: number;
+    lastGuideEndedAt: number | null;
+    dismissedCounts: Record<string, number>;
+    snoozedUntil: Record<string, number>;
+}
+export declare function createDefaultSessionStats(): SessionStats;

package/dist/lib/guidance/storage/storage-keys.js

@@ -0,0 +1,23 @@
+function t(n, e, i) {
+  return `guidance:${n}:${e}:${i}`;
+}
+function s(n, e) {
+  return `guidance:${n}:campaign:${e}`;
+}
+function u(n) {
+  return `guidance:${n}:session:stats`;
+}
+function a() {
+  return {
+    guidesShownThisSession: 0,
+    lastGuideEndedAt: null,
+    dismissedCounts: {},
+    snoozedUntil: {}
+  };
+}
+export {
+  s as buildCampaignStorageKey,
+  t as buildGuidanceStorageKey,
+  u as buildSessionStatsKey,
+  a as createDefaultSessionStats
+};

package/dist/lib/guidance/targets/ref-registry.d.ts

@@ -0,0 +1,12 @@
+import { ResolvedTarget, TargetDescriptor } from '../types/guidance.types';
+export declare class GuidanceTargetRefRegistry {
+    private readonly targets;
+    private finalizationRegistry;
+    constructor();
+    register(targetId: string, element: HTMLElement, scope?: string): () => void;
+    unregister(targetId: string): void;
+    clearScope(scope: string): void;
+    resolve(targetId: string): ResolvedTarget | null;
+    resolveDescriptor(descriptor: TargetDescriptor, scopeRoot?: HTMLElement | null): ResolvedTarget | null;
+}
+export declare const globalGuidanceTargetRefRegistry: GuidanceTargetRefRegistry;

package/dist/lib/guidance/targets/ref-registry.js

@@ -0,0 +1,65 @@
+class o {
+  targets = /* @__PURE__ */ new Map();
+  finalizationRegistry = null;
+  constructor() {
+    typeof FinalizationRegistry < "u" && (this.finalizationRegistry = new FinalizationRegistry(
+      (e) => {
+        this.targets.delete(e);
+      }
+    ));
+  }
+  register(e, t, r) {
+    return this.targets.size >= 500 && process.env.NODE_ENV === "development" && console.warn(
+      "[guidance] Target registry exceeded 500 entries"
+    ), this.targets.set(e, {
+      targetId: e,
+      elementRef: new WeakRef(t),
+      scope: r
+    }), this.finalizationRegistry?.register(t, e), () => {
+      this.unregister(e);
+    };
+  }
+  unregister(e) {
+    this.targets.delete(e);
+  }
+  clearScope(e) {
+    for (const [t, r] of this.targets.entries())
+      r.scope === e && this.targets.delete(t);
+  }
+  resolve(e) {
+    const t = this.targets.get(e);
+    if (!t)
+      return null;
+    const r = t.elementRef.deref() ?? null;
+    return {
+      targetId: e,
+      element: r,
+      rect: r?.getBoundingClientRect() ?? null,
+      source: "ref"
+    };
+  }
+  resolveDescriptor(e, t) {
+    const r = this.resolve(e.targetId);
+    if (r?.element)
+      return r;
+    if (typeof document > "u")
+      return null;
+    const s = t ?? document, i = `[data-guidance-target="${e.targetId}"]`, n = s === document ? document.querySelector(i) : s.querySelector(i);
+    return n ? {
+      targetId: e.targetId,
+      element: n,
+      rect: n.getBoundingClientRect(),
+      source: "selector"
+    } : {
+      targetId: e.targetId,
+      element: null,
+      rect: null,
+      source: "selector"
+    };
+  }
+}
+const g = new o();
+export {
+  o as GuidanceTargetRefRegistry,
+  g as globalGuidanceTargetRefRegistry
+};

package/dist/lib/guidance/targets/target-resolver.d.ts

@@ -0,0 +1,13 @@
+import { GuidancePlugin, ResolvedTarget, TargetDescriptor } from '../types/guidance.types';
+import { GuidanceTargetRefRegistry } from './ref-registry';
+export declare class TargetResolver {
+    private readonly adapterPlugins;
+    private readonly refRegistry;
+    constructor(refRegistry: GuidanceTargetRefRegistry);
+    registerAdapter(plugin: GuidancePlugin): void;
+    unregisterAdapter(pluginType: string): void;
+    resolve(descriptor: TargetDescriptor, scopeRoot?: HTMLElement | null, adapterType?: string, adapterConfig?: Record<string, unknown>): ResolvedTarget | null;
+}
+export declare function resolveTargetSynchronously(resolver: TargetResolver, descriptor: TargetDescriptor): ResolvedTarget | null;
+export declare function waitForTargetResolved(resolver: TargetResolver, descriptor: TargetDescriptor, timeoutMs?: number): Promise<ResolvedTarget | null>;
+export declare function waitForTargetVisible(element: HTMLElement, timeoutMs?: number): Promise<boolean>;

package/dist/lib/guidance/targets/target-resolver.js

@@ -0,0 +1,85 @@
+class f {
+  adapterPlugins = /* @__PURE__ */ new Map();
+  refRegistry;
+  constructor(e) {
+    this.refRegistry = e;
+  }
+  registerAdapter(e) {
+    this.adapterPlugins.set(e.type, e);
+  }
+  unregisterAdapter(e) {
+    this.adapterPlugins.delete(e);
+  }
+  resolve(e, t, n, r) {
+    if (n) {
+      const s = this.adapterPlugins.get(n);
+      if (s?.resolve) {
+        const o = {
+          targetDescriptor: e,
+          scopeRoot: t
+        };
+        try {
+          const l = s.resolve(
+            o,
+            r ?? {}
+          );
+          if (l && !(l instanceof Promise))
+            return l;
+        } catch {
+          return null;
+        }
+      }
+    }
+    return this.refRegistry.resolveDescriptor(e, t);
+  }
+}
+const c = 16;
+function u(i) {
+  const e = i.getBoundingClientRect();
+  return e.width > 0 && e.height > 0;
+}
+function d(i, e) {
+  const t = i.resolve(e);
+  return !t?.element || e.waitUntil === "visible" && !u(t.element) ? null : t;
+}
+async function w(i, e, t = 5e3) {
+  const n = Date.now();
+  for (; Date.now() - n < t; ) {
+    const r = i.resolve(e);
+    if (r?.element)
+      if (e.waitUntil === "visible") {
+        const s = t - (Date.now() - n);
+        if (await g(
+          r.element,
+          Math.max(s, c)
+        ))
+          return r;
+      } else
+        return r;
+    await new Promise((s) => {
+      window.setTimeout(s, c);
+    });
+  }
+  return null;
+}
+function g(i, e = 5e3) {
+  if (typeof window > "u" || typeof IntersectionObserver > "u")
+    return Promise.resolve(!0);
+  const t = i.getBoundingClientRect();
+  return t.width > 0 && t.height > 0 ? Promise.resolve(!0) : new Promise((n) => {
+    const r = new IntersectionObserver((o) => {
+      o.some(
+        (a) => a.isIntersecting && a.intersectionRatio > 0
+      ) && (r.disconnect(), clearTimeout(s), n(!0));
+    }), s = setTimeout(() => {
+      r.disconnect(), n(!1);
+    }, e);
+    r.observe(i);
+  });
+}
+export {
+  f as TargetResolver,
+  d as resolveTargetSynchronously,
+  w as waitForTargetResolved,
+  g as waitForTargetVisible
+};

package/dist/lib/guidance/triggers/built-in-triggers.d.ts

@@ -0,0 +1,14 @@
+import { GuidancePlugin } from '../types/guidance.types';
+export declare function createRouteEnteredTriggerPlugin(): GuidancePlugin;
+export declare function createRouteExitedTriggerPlugin(): GuidancePlugin;
+export declare function createFirstVisitTriggerPlugin(): GuidancePlugin;
+export declare function createNthVisitTriggerPlugin(): GuidancePlugin;
+export declare function createAppVersionTriggerPlugin(): GuidancePlugin;
+export declare function createFeatureFlagTriggerPlugin(): GuidancePlugin;
+export declare function createPermissionTriggerPlugin(): GuidancePlugin;
+export declare function createUserSegmentTriggerPlugin(): GuidancePlugin;
+export declare function createCustomEventTriggerPlugin(): GuidancePlugin;
+export declare function createManualTriggerPlugin(): GuidancePlugin;
+export declare function registerBuiltInTriggerPlugins(registry: {
+    register: (plugin: GuidancePlugin) => void;
+}): void;

package/dist/lib/guidance/triggers/built-in-triggers.js

@@ -0,0 +1,88 @@
+function n() {
+  return {
+    type: "trigger.route-entered",
+    evaluate: (e, t) => {
+      const r = String(t.path ?? "");
+      return t.exact ? e.routePath === r : e.routePath.startsWith(r);
+    }
+  };
+}
+function u() {
+  return {
+    type: "trigger.route-exited",
+    evaluate: (e, t) => !e.routePath.startsWith(String(t.path ?? ""))
+  };
+}
+function g() {
+  return {
+    type: "trigger.first-visit",
+    evaluate: (e, t) => {
+      const r = String(t.guideId ?? "");
+      return (e.visitCounts[r] ?? 0) === 0;
+    }
+  };
+}
+function a() {
+  return {
+    type: "trigger.nth-visit",
+    evaluate: (e, t) => {
+      const r = String(t.guideId ?? ""), i = Number(t.count ?? 0);
+      return (e.visitCounts[r] ?? 0) === i;
+    }
+  };
+}
+function s() {
+  return {
+    type: "trigger.app-version",
+    evaluate: (e, t) => e.appVersion === String(t.version ?? "")
+  };
+}
+function o() {
+  return {
+    type: "trigger.feature-flag",
+    evaluate: (e, t) => {
+      const r = String(t.flag ?? ""), i = e.featureFlags[r] ?? !1;
+      return t.enabled === void 0 ? i : i === !!t.enabled;
+    }
+  };
+}
+function l() {
+  return {
+    type: "trigger.permission",
+    evaluate: (e, t) => e.permissions.includes(String(t.permission ?? ""))
+  };
+}
+function c() {
+  return {
+    type: "trigger.user-segment",
+    evaluate: (e, t) => e.userSegments.includes(String(t.segment ?? ""))
+  };
+}
+function p() {
+  return {
+    type: "trigger.custom-event",
+    evaluate: (e, t) => e.customEvents.has(String(t.event ?? ""))
+  };
+}
+function v() {
+  return {
+    type: "trigger.manual",
+    evaluate: () => !1
+  };
+}
+function f(e) {
+  e.register(n()), e.register(u()), e.register(g()), e.register(a()), e.register(s()), e.register(o()), e.register(l()), e.register(c()), e.register(p()), e.register(v());
+}
+export {
+  s as createAppVersionTriggerPlugin,
+  p as createCustomEventTriggerPlugin,
+  o as createFeatureFlagTriggerPlugin,
+  g as createFirstVisitTriggerPlugin,
+  v as createManualTriggerPlugin,
+  a as createNthVisitTriggerPlugin,
+  l as createPermissionTriggerPlugin,
+  n as createRouteEnteredTriggerPlugin,
+  u as createRouteExitedTriggerPlugin,
+  c as createUserSegmentTriggerPlugin,
+  f as registerBuiltInTriggerPlugins
+};

package/dist/lib/guidance/triggers/trigger-registry.d.ts

@@ -0,0 +1,9 @@
+import { GuidancePlugin, TriggerContext, TriggerExpression } from '../types/guidance.types';
+export declare class TriggerPluginRegistry {
+    private readonly plugins;
+    register(plugin: GuidancePlugin): void;
+    unregister(pluginType: string): void;
+    get(pluginType: string): GuidancePlugin | undefined;
+    evaluateExpression(expression: TriggerExpression, context: TriggerContext): Promise<boolean>;
+    evaluateAll(expressions: TriggerExpression[], context: TriggerContext): Promise<boolean>;
+}

package/dist/lib/guidance/triggers/trigger-registry.js

@@ -0,0 +1,44 @@
+class r {
+  plugins = /* @__PURE__ */ new Map();
+  register(t) {
+    this.plugins.set(t.type, t);
+  }
+  unregister(t) {
+    this.plugins.delete(t);
+  }
+  get(t) {
+    return this.plugins.get(t);
+  }
+  async evaluateExpression(t, e) {
+    if ("op" in t) {
+      if (t.op === "not") {
+        const i = t.conditions[0];
+        return i ? !await this.evaluateExpression(i, e) : !1;
+      }
+      const a = await Promise.all(
+        t.conditions.map(
+          (i) => this.evaluateExpression(i, e)
+        )
+      );
+      return t.op === "and" ? a.every(Boolean) : a.some(Boolean);
+    }
+    const n = this.plugins.get(t.plugin);
+    if (!n?.evaluate)
+      return !1;
+    try {
+      return !!await n.evaluate(e, t.config ?? {});
+    } catch {
+      return !1;
+    }
+  }
+  async evaluateAll(t, e) {
+    return t.length ? (await Promise.all(
+      t.map(
+        (a) => this.evaluateExpression(a, e)
+      )
+    )).every(Boolean) : !0;
+  }
+}
+export {
+  r as TriggerPluginRegistry
+};