@mrrocket/sdk 0.4.0 → 0.9.0

package/dist/flows.d.ts

@@ -0,0 +1,222 @@
+/**
+ * The cancel flow, onboarding and in-app messages (SDK 0.7.0): what MRRocket's config and `GET /api/sdk/inapp` serve,
+ * and one controller that decides what shows when and records what the person did. No DOM and no React: the web
+ * renderer (flows-ui.ts, loaded only when something shows) and the React Native one (native/flows-view.ts) draw
+ * `view()` and call the actions.
+ *
+ * What it records, as normal events under the SDK's analytics consent (nothing with consent "off"):
+ * - `$cancel_flow` `{action: "shown" | "answered" | "offer" | "finished", run, version, …}`. MRRocket turns a
+ *   `finished` with `outcome: "saved"` into a save and with `outcome: "cancelled"` into a cancellation on the Churn page.
+ *   MRRocket never changes a subscription: an accepted offer goes to the app's `onSave`, a confirmed cancel to its
+ *   `onCancel`, and only after they succeed is the outcome recorded.
+ * - `$onboarding` `{flow, step?, action: "started" | "shown" | "completed" | "dismissed"}`.
+ * - `$inapp` `{message, journey, action: "shown" | "clicked" | "dismissed"}`; the journey moves the person on.
+ */
+import type { CockpitConfig } from "./core.js";
+export declare const CANCEL_EVENT = "$cancel_flow";
+export declare const ONBOARDING_EVENT = "$onboarding";
+export declare const INAPP_EVENT = "$inapp";
+export type CancelOfferKind = "discount" | "pause" | "downgrade" | "contact";
+/** What one answer of the survey offers before the confirmation. An answer without one goes straight to it. */
+export interface CancelOffer {
+    kind: CancelOfferKind;
+    headline: string;
+    /** Discount: percent off. */
+    percent?: number;
+    /** Discount: for how many months; pause: up to how many months. */
+    months?: number;
+    /** Downgrade: the plan to switch to, as MRRocket knows it from the payment provider. */
+    plan?: string;
+    planName?: string;
+}
+/** The product's live cancel flow (MRRocket › Churn › Cancel flow). */
+export interface CancelFlowConfig {
+    /** Grows with every publish. */
+    version: number;
+    question: string;
+    /** The survey's answers, in order. */
+    reasons: {
+        id: string;
+        label: string;
+    }[];
+    /** The offer per answer id. */
+    offers: Record<string, CancelOffer>;
+    confirm: {
+        title: string;
+        body: string;
+        button: string;
+    };
+    /**
+     * Who gets the survey and the offers: business customers only. Anyone else (a consumer, or a customer the app does
+     * not say) gets the plain confirmation, with nothing in the way of cancelling (§ 312k BGB).
+     */
+    offersFor: "business";
+}
+export type OnboardingStepKind = "tour" | "checklist" | "modal";
+export interface OnboardingStep {
+    id: string;
+    kind: OnboardingStepKind;
+    title: string;
+    body?: string;
+    button?: string;
+    /** Tour steps: the element they point at, marked `data-ck-target="<target>"` in the app. Without it: a card. */
+    target?: string;
+    /** Checklist items: the event that ticks them (`track("<event>")`). Without it the person ticks it themselves. */
+    event?: string;
+}
+/** A live onboarding flow's in-app steps (MRRocket › Conversion › Onboarding); its emails go out from MRRocket. */
+export interface OnboardingFlow {
+    id: string;
+    name: string;
+    /** When it starts: an event's words ("Signed up", "First export"), or "First launch" / "First visit". */
+    trigger: string;
+    steps: OnboardingStep[];
+}
+/** An in-app message a Lifecycle journey has for this person. */
+export interface InAppMessage {
+    id: string;
+    journey?: string;
+    title: string;
+    body?: string;
+    button?: string;
+    /** Where the button goes (http(s) or a path of the app). */
+    url?: string;
+    style: "banner" | "modal";
+}
+/** What `GET /api/sdk/inapp` answers for one signed-in person. */
+export interface InAppState {
+    /** Progress per onboarding flow: the steps done and whether the person closed it. */
+    onboarding: Record<string, {
+        done: string[];
+        dismissed?: boolean;
+    }>;
+    messages: InAppMessage[];
+}
+export interface CancelFlowResult {
+    /** "cancelled": confirmed; "saved": took the offer; "kept": closed the dialog without cancelling. */
+    outcome: "cancelled" | "saved" | "kept";
+    reason?: string;
+    reasonLabel?: string;
+    offer?: CancelOffer;
+    /** What the customer wrote on the confirmation, if anything. */
+    comment?: string;
+    /** This run's id, the same as in the events. */
+    run: string;
+}
+export interface CancelFlowOptions {
+    /**
+     * "business" shows the survey and the offers; anything else (the default) only the plain confirmation, so a
+     * consumer can always cancel in one step (§ 312k BGB).
+     */
+    customer?: "business" | "consumer";
+    /** The customer's current price, to show what a discount costs (`{ amount: 29, currency: "EUR" }`). */
+    price?: {
+        amount: number;
+        currency: string;
+        interval?: "month" | "year";
+    };
+    /** The customer confirmed: cancel the subscription in your code. Throwing keeps the dialog open with an error. */
+    onCancel?: (result: CancelFlowResult) => unknown;
+    /** The customer took an offer: apply it in your code (coupon, pause, plan change). Throwing keeps the dialog open. */
+    onSave?: (result: CancelFlowResult) => unknown;
+    /** Closed without cancelling or taking an offer. */
+    onClose?: (result: CancelFlowResult) => void;
+}
+/** What a renderer draws. */
+export type FlowView = {
+    type: "cancel";
+    screen: "survey" | "offer" | "confirm";
+    flow: CancelFlowConfig;
+    /** The answer picked on the survey. */
+    reason?: string;
+    offer?: CancelOffer;
+    price?: CancelFlowOptions["price"];
+    busy: boolean;
+    error?: string;
+    /** The step for the dots, 1 to `steps`. */
+    step: number;
+    steps: number;
+} | {
+    type: "step";
+    flow: OnboardingFlow;
+    step: OnboardingStep;
+    index: number;
+    total: number;
+    last: boolean;
+} | {
+    type: "checklist";
+    flow: OnboardingFlow;
+    items: {
+        step: OnboardingStep;
+        done: boolean;
+    }[];
+} | {
+    type: "message";
+    message: InAppMessage;
+};
+export interface FlowsEnv {
+    /** Records an event under the SDK's consent (the normal queue). */
+    track(event: string, props?: Record<string, unknown>): void;
+    /** Whose messages and progress these are: the identify() id; undefined while nobody is signed in. */
+    personId(): string | undefined;
+    /** `GET /api/sdk/inapp` for that person; null when it fails. */
+    fetchInApp(personId: string): Promise<InAppState | null>;
+    /** Keeps onboarding progress on the device; only while the consent lets the SDK store something. */
+    storage?: () => {
+        get(key: string): string | null | Promise<string | null>;
+        set(key: string, value: string): void;
+    } | null;
+    /** Opens a message's link. */
+    openUrl?: (url: string) => void;
+    /** Start onboarding flows by their trigger on its own (default true). */
+    auto?: boolean;
+}
+export interface FlowsController {
+    setConfig(config: CockpitConfig | null): void;
+    /** The person changed (identify, reset, consent): loads their messages and onboarding progress. */
+    refresh(): Promise<void>;
+    /** An event the app recorded: starts flows whose trigger it is and ticks checklist items. */
+    onEvent(name: string): void;
+    openCancelFlow(options?: CancelFlowOptions): Promise<CancelFlowResult>;
+    /** Starts an onboarding flow now (the first live one without an id). False when there is none to start. */
+    startOnboarding(id?: string): boolean;
+    view(): FlowView | null;
+    subscribe(listener: () => void): () => void;
+    /** `accept(comment)`: a "Talk to us" offer sends what the customer wrote with it. */
+    cancel: {
+        pick(reason: string): void;
+        next(): void;
+        accept(comment?: string): void;
+        decline(): void;
+        confirm(comment?: string): void;
+        close(): void;
+    };
+    onboarding: {
+        next(): void;
+        check(stepId: string): void;
+        dismiss(): void;
+    };
+    message: {
+        click(): void;
+        dismiss(): void;
+    };
+}
+/** The plain confirmation, when the product has no live cancel flow (or MRRocket was not reachable). */
+export declare const PLAIN_CANCEL: CancelFlowConfig;
+/** `"Signed up"` → `signed_up`, the way MRRocket names events from words. */
+export declare const eventSlug: (s: string) => string;
+/** Whether recording `event` is the trigger's moment ("Signed up" is any of the usual signup event names). */
+export declare const matchesTrigger: (trigger: string, event: string) => boolean;
+/** Triggers that mean "the first time the person opens the app": the flow starts on load until it is done. */
+export declare const startsOnLoad: (trigger: string) => boolean;
+/** A random id for one cancel flow run. */
+export declare const runId: () => string;
+/** The money a discount leaves: `29 EUR` at 30 % → `20.30`. */
+export declare const discounted: (amount: number, percent: number) => number;
+/** "€20.30" in the customer's own currency, without a library. */
+export declare const money: (amount: number, currency: string) => string;
+/** The button of an offer. */
+export declare const offerButton: (o: CancelOffer) => "Send to the team" | "Pause instead" | "Switch plan" | "Accept offer";
+/** A link a message may open: http(s), or a path of the app. Nothing else (no `javascript:`). */
+export declare const safeUrl: (url: string | undefined) => string | undefined;
+export declare const createFlows: (env: FlowsEnv) => FlowsController;

package/dist/flows.js

@@ -0,0 +1,409 @@
+// src/flows.ts
+var CANCEL_EVENT = "$cancel_flow";
+var ONBOARDING_EVENT = "$onboarding";
+var INAPP_EVENT = "$inapp";
+var PLAIN_CANCEL = {
+  version: 0,
+  question: "",
+  reasons: [],
+  offers: {},
+  confirm: { title: "Cancel your subscription?", body: "You keep access until the end of the billing period.", button: "Cancel subscription" },
+  offersFor: "business"
+};
+var FAILED = "Something went wrong. Please try again.";
+var PROGRESS_KEY = "mrrocket:onboarding";
+var eventSlug = (s) => s.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+var SIGNUP = /* @__PURE__ */ new Set(["signed_up", "signup", "sign_up", "registered", "account_created", "user_signed_up"]);
+var matchesTrigger = (trigger, event) => {
+  const t = eventSlug(trigger);
+  const e = eventSlug(event);
+  if (!t || !e) return false;
+  return t === e || SIGNUP.has(t) && SIGNUP.has(e);
+};
+var startsOnLoad = (trigger) => /^(first (launch|visit|open|session|login|sign ?in|app open)|app (opened|launched)|on load|every visit|always)?$/i.test(trigger.trim());
+var runId = () => `cf_${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
+var discounted = (amount, percent) => Math.round(amount * (1 - percent / 100) * 100) / 100;
+var money = (amount, currency) => {
+  try {
+    return new Intl.NumberFormat(void 0, { style: "currency", currency }).format(amount);
+  } catch {
+    return `${amount.toFixed(2)} ${currency}`;
+  }
+};
+var offerButton = (o) => o.kind === "contact" ? "Send to the team" : o.kind === "pause" ? "Pause instead" : o.kind === "downgrade" ? "Switch plan" : "Accept offer";
+var safeUrl = (url) => {
+  const u = (url ?? "").trim();
+  return /^https?:\/\//i.test(u) || /^\/(?!\/)/.test(u) ? u : void 0;
+};
+var createFlows = (env) => {
+  let config = null;
+  let cancel = null;
+  let active = null;
+  let messages = [];
+  let known = false;
+  let loading = null;
+  let loadedFor;
+  let progressFor = null;
+  const progress = /* @__PURE__ */ new Map();
+  const handled = /* @__PURE__ */ new Set();
+  const shown = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  const auto = env.auto !== false;
+  const flows = () => config?.onboarding ?? [];
+  const flowById = (id) => id ? flows().find((f) => f.id === id) : void 0;
+  const prog = (id) => {
+    let p = progress.get(id);
+    if (!p) progress.set(id, p = { done: /* @__PURE__ */ new Set(), dismissed: false });
+    return p;
+  };
+  const finished = (f) => {
+    const p = progress.get(f.id);
+    return !!p && (p.dismissed || f.steps.every((s) => p.done.has(s.id)));
+  };
+  const keyOf = (pid) => `${PROGRESS_KEY}:${pid ?? "visitor"}`;
+  const save = () => {
+    const store = env.storage?.();
+    if (!store) return;
+    const out = {};
+    for (const [id, p] of progress) out[id] = { done: [...p.done], ...p.dismissed ? { dismissed: true } : {} };
+    try {
+      store.set(keyOf(env.personId()), JSON.stringify(out));
+    } catch {
+    }
+  };
+  const merge = (state) => {
+    for (const [id, s] of Object.entries(state ?? {})) {
+      const p = prog(id);
+      for (const d of s.done ?? []) p.done.add(d);
+      if (s.dismissed) p.dismissed = true;
+    }
+  };
+  const onboardingView = () => {
+    const flow = flowById(active);
+    if (!flow) return null;
+    const p = prog(flow.id);
+    const at = flow.steps.findIndex((s) => !p.done.has(s.id));
+    if (at < 0 || p.dismissed) return null;
+    const step = flow.steps[at];
+    if (step.kind === "checklist") {
+      let from = at;
+      while (from > 0 && flow.steps[from - 1].kind === "checklist") from--;
+      let to = at;
+      while (to + 1 < flow.steps.length && flow.steps[to + 1].kind === "checklist") to++;
+      return { type: "checklist", flow, items: flow.steps.slice(from, to + 1).map((s) => ({ step: s, done: p.done.has(s.id) })) };
+    }
+    return { type: "step", flow, step, index: at, total: flow.steps.length, last: at === flow.steps.length - 1 };
+  };
+  const view = () => {
+    if (cancel) {
+      const offer = cancel.reason ? cancel.flow.offers[cancel.reason] : void 0;
+      return {
+        type: "cancel",
+        screen: cancel.screen,
+        flow: cancel.flow,
+        reason: cancel.reason,
+        offer: cancel.screen === "offer" ? offer : void 0,
+        price: cancel.options.price,
+        busy: cancel.busy,
+        error: cancel.error,
+        step: cancel.plain ? 1 : cancel.screen === "survey" ? 1 : cancel.screen === "offer" ? 2 : 3,
+        steps: cancel.plain ? 1 : 3
+      };
+    }
+    const ob = onboardingView();
+    if (ob) return ob;
+    if (active) active = null;
+    const m = messages.find((x) => !handled.has(x.id));
+    return m ? { type: "message", message: m } : null;
+  };
+  const emit = () => {
+    const v = view();
+    if (v?.type === "step" && !shown.has(`s:${v.step.id}`)) {
+      shown.add(`s:${v.step.id}`);
+      env.track(ONBOARDING_EVENT, { flow: v.flow.id, step: v.step.id, kind: v.step.kind, action: "shown" });
+    } else if (v?.type === "checklist") {
+      for (const i of v.items)
+        if (!i.done && !shown.has(`s:${i.step.id}`)) {
+          shown.add(`s:${i.step.id}`);
+          env.track(ONBOARDING_EVENT, { flow: v.flow.id, step: i.step.id, kind: "checklist", action: "shown" });
+        }
+    } else if (v?.type === "message" && !shown.has(`m:${v.message.id}`)) {
+      shown.add(`m:${v.message.id}`);
+      env.track(INAPP_EVENT, { message: v.message.id, journey: v.message.journey, action: "shown" });
+    }
+    for (const l of [...listeners]) {
+      try {
+        l();
+      } catch {
+      }
+    }
+  };
+  const start = (flow) => {
+    if (active === flow.id) return true;
+    if (active && flowById(active) && !finished(flowById(active))) return false;
+    active = flow.id;
+    env.track(ONBOARDING_EVENT, { flow: flow.id, action: "started" });
+    emit();
+    return true;
+  };
+  const autoStart = () => {
+    if (!auto || active || !known) return;
+    if (!env.personId() && !env.storage?.()) return;
+    const next = flows().find((f) => startsOnLoad(f.trigger) && f.steps.length && !finished(f));
+    if (next) start(next);
+  };
+  const refresh = () => {
+    const pid = env.personId();
+    if (progressFor !== null && progressFor !== pid) {
+      progress.clear();
+      handled.clear();
+      active = null;
+      loadedFor = void 0;
+    }
+    progressFor = pid;
+    const run = (async () => {
+      const store = env.storage?.();
+      if (store) {
+        try {
+          const raw = await store.get(keyOf(pid));
+          if (raw) merge(JSON.parse(raw));
+        } catch {
+        }
+      }
+      const wants = flows().length > 0 || !!config?.messages;
+      if (pid && wants && loadedFor !== pid) {
+        loadedFor = pid;
+        const state = await env.fetchInApp(pid).catch(() => null);
+        if (state && env.personId() === pid) {
+          merge(state.onboarding);
+          messages = (state.messages ?? []).filter((m) => m && m.id && m.title);
+        }
+      }
+      if (!pid) messages = [];
+      known = true;
+      autoStart();
+      emit();
+    })();
+    loading = run.finally(() => {
+      if (loading === run) loading = null;
+    });
+    return loading;
+  };
+  const result = (c, outcome, comment) => {
+    const offer = c.reason ? c.flow.offers[c.reason] : void 0;
+    return {
+      outcome,
+      run: c.run,
+      ...c.reason ? { reason: c.reason, reasonLabel: c.flow.reasons.find((r) => r.id === c.reason)?.label } : {},
+      ...outcome === "saved" && offer ? { offer } : {},
+      ...comment?.trim() ? { comment: comment.trim().slice(0, 500) } : {}
+    };
+  };
+  const finish = (c, r) => {
+    env.track(CANCEL_EVENT, {
+      action: "finished",
+      run: c.run,
+      version: c.flow.version,
+      outcome: r.outcome,
+      customer: c.options.customer ?? "consumer",
+      ...r.reason ? { reason: r.reason } : {},
+      ...r.offer ? { offer: r.offer.kind } : {},
+      ...r.comment ? { comment: r.comment } : {}
+    });
+    if (cancel === c) cancel = null;
+    c.resolve(r);
+    emit();
+  };
+  const settle = (c, outcome, comment) => {
+    if (c.busy) return;
+    const r = result(c, outcome, comment);
+    const fn = outcome === "saved" ? c.options.onSave : c.options.onCancel;
+    c.busy = true;
+    c.error = void 0;
+    emit();
+    Promise.resolve().then(() => fn?.(r)).then(
+      () => finish(c, r),
+      () => {
+        c.busy = false;
+        c.error = FAILED;
+        emit();
+      }
+    );
+  };
+  const openCancelFlow = (options = {}) => {
+    if (cancel) return cancel.promise;
+    const flow = config?.cancelFlow ?? PLAIN_CANCEL;
+    const plain = options.customer !== "business" || flow.reasons.length < 2;
+    let resolve = () => {
+    };
+    const promise = new Promise((r) => resolve = r);
+    const c = { flow, options, plain, screen: plain ? "confirm" : "survey", run: runId(), busy: false, resolve, promise };
+    cancel = c;
+    env.track(CANCEL_EVENT, { action: "shown", run: c.run, version: flow.version, customer: options.customer ?? "consumer", plain });
+    emit();
+    return promise;
+  };
+  const controller = {
+    setConfig: (c) => {
+      config = c;
+      if (active && !flowById(active)) active = null;
+      emit();
+    },
+    refresh,
+    onEvent: (name) => {
+      if (!name || name.startsWith("$")) return;
+      const flow = flowById(active);
+      let ticked = false;
+      if (flow) {
+        const p = prog(flow.id);
+        for (const s of flow.steps)
+          if (s.kind === "checklist" && s.event && !p.done.has(s.id) && matchesTrigger(s.event, name)) {
+            p.done.add(s.id);
+            ticked = true;
+            env.track(ONBOARDING_EVENT, { flow: flow.id, step: s.id, kind: s.kind, action: "completed" });
+          }
+      }
+      if (ticked) {
+        save();
+        emit();
+      }
+      if (!auto || !env.personId() && !env.storage?.()) return;
+      const next = flows().find((f) => f.steps.length && matchesTrigger(f.trigger, name) && !finished(f));
+      if (next) start(next);
+    },
+    openCancelFlow,
+    startOnboarding: (id) => {
+      const f = id ? flowById(id) : flows().find((x) => x.steps.length && !finished(x));
+      if (!f || !f.steps.length) return false;
+      const p = prog(f.id);
+      p.dismissed = false;
+      return start(f);
+    },
+    view,
+    subscribe: (l) => {
+      listeners.add(l);
+      return () => listeners.delete(l);
+    },
+    cancel: {
+      pick: (reason) => {
+        if (!cancel || cancel.busy || !cancel.flow.reasons.some((r) => r.id === reason)) return;
+        cancel.reason = reason;
+        cancel.error = void 0;
+        emit();
+      },
+      next: () => {
+        const c = cancel;
+        if (!c || c.screen !== "survey" || !c.reason) return;
+        env.track(CANCEL_EVENT, { action: "answered", run: c.run, version: c.flow.version, reason: c.reason });
+        c.screen = c.flow.offers[c.reason] ? "offer" : "confirm";
+        emit();
+      },
+      accept: (comment) => {
+        const c = cancel;
+        if (!c || c.screen !== "offer" || !c.reason) return;
+        const offer = c.flow.offers[c.reason];
+        if (!c.busy)
+          env.track(CANCEL_EVENT, {
+            action: "offer",
+            run: c.run,
+            version: c.flow.version,
+            reason: c.reason,
+            offer: offer?.kind,
+            outcome: "accepted"
+          });
+        settle(c, "saved", comment);
+      },
+      decline: () => {
+        const c = cancel;
+        if (!c || c.screen !== "offer" || c.busy) return;
+        env.track(CANCEL_EVENT, {
+          action: "offer",
+          run: c.run,
+          version: c.flow.version,
+          reason: c.reason,
+          offer: c.reason ? c.flow.offers[c.reason]?.kind : void 0,
+          outcome: "declined"
+        });
+        c.screen = "confirm";
+        c.error = void 0;
+        emit();
+      },
+      confirm: (comment) => {
+        const c = cancel;
+        if (!c || c.screen !== "confirm") return;
+        settle(c, "cancelled", comment);
+      },
+      close: () => {
+        const c = cancel;
+        if (!c || c.busy) return;
+        const r = result(c, "kept");
+        c.options.onClose?.(r);
+        finish(c, r);
+      }
+    },
+    onboarding: {
+      next: () => {
+        const v = onboardingView();
+        if (v?.type !== "step") return;
+        prog(v.flow.id).done.add(v.step.id);
+        env.track(ONBOARDING_EVENT, { flow: v.flow.id, step: v.step.id, kind: v.step.kind, action: "completed" });
+        save();
+        emit();
+      },
+      check: (stepId) => {
+        const v = onboardingView();
+        if (v?.type !== "checklist") return;
+        const item = v.items.find((i) => i.step.id === stepId);
+        if (!item || item.done) return;
+        prog(v.flow.id).done.add(stepId);
+        env.track(ONBOARDING_EVENT, { flow: v.flow.id, step: stepId, kind: "checklist", action: "completed" });
+        save();
+        emit();
+      },
+      dismiss: () => {
+        const v = onboardingView();
+        if (!v || v.type !== "step" && v.type !== "checklist") return;
+        prog(v.flow.id).dismissed = true;
+        env.track(ONBOARDING_EVENT, { flow: v.flow.id, ...v.type === "step" ? { step: v.step.id } : {}, action: "dismissed" });
+        active = null;
+        save();
+        emit();
+      }
+    },
+    message: {
+      click: () => {
+        const v = view();
+        if (v?.type !== "message") return;
+        handled.add(v.message.id);
+        env.track(INAPP_EVENT, { message: v.message.id, journey: v.message.journey, action: "clicked" });
+        const url = safeUrl(v.message.url);
+        emit();
+        if (url) env.openUrl?.(url);
+      },
+      dismiss: () => {
+        const v = view();
+        if (v?.type !== "message") return;
+        handled.add(v.message.id);
+        env.track(INAPP_EVENT, { message: v.message.id, journey: v.message.journey, action: "dismissed" });
+        emit();
+      }
+    }
+  };
+  return controller;
+};
+export {
+  CANCEL_EVENT,
+  INAPP_EVENT,
+  ONBOARDING_EVENT,
+  PLAIN_CANCEL,
+  createFlows,
+  discounted,
+  eventSlug,
+  matchesTrigger,
+  money,
+  offerButton,
+  runId,
+  safeUrl,
+  startsOnLoad
+};
+//# sourceMappingURL=flows.js.map