@funnelsgrove/runtime 0.1.0 → 0.1.2

package/dist/content/step-content.d.ts

@@ -0,0 +1,130 @@
+export type StepImage = {
+    src: string;
+    alt?: string;
+};
+export type ChoiceItem = {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    image?: StepImage;
+    badge?: string;
+    value?: string;
+};
+export type InfoItem = {
+    id: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    image?: StepImage;
+    badge?: string;
+    meta?: string;
+};
+export type QuoteItem = {
+    id: string;
+    quote: string;
+    author: string;
+    role?: string;
+    avatar?: StepImage;
+    rating?: number;
+};
+export type ImageItem = {
+    id: string;
+    image: StepImage;
+    label?: string;
+};
+export type QaItem = {
+    id: string;
+    question: string;
+    answer?: string;
+};
+export type LinkItem = {
+    id: string;
+    label: string;
+    href?: string;
+};
+export type ReasonItem = {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+};
+export type StoreLinkItem = {
+    id: string;
+    eyebrow: string;
+    title: string;
+    href: string;
+    variant?: string;
+};
+export type PlanPresentationItem = {
+    id: string;
+    title?: string;
+    description?: string;
+    badge?: string;
+};
+export type StepChoiceItem = ChoiceItem;
+export type StepInfoItem = InfoItem;
+export type StepQuoteItem = QuoteItem;
+export type StepImageItem = ImageItem;
+export type StepQaItem = QaItem;
+export type StepLinkItem = LinkItem;
+export type StepReasonItem = ReasonItem;
+export type StepStoreLinkItem = StoreLinkItem;
+export type StepPlanPresentationItem = PlanPresentationItem;
+export type LocalizedStepContent<TLocaleContent, TLocaleCode extends string = string> = {
+    defaultLocale: TLocaleCode;
+    locales: Record<TLocaleCode, TLocaleContent>;
+};
+export type CountryPricingOverride<TOfferKey extends string = string> = {
+    defaultOfferKey?: TOfferKey;
+    offerOrder?: readonly TOfferKey[];
+};
+export type CountryPricingProfile<TOfferKey extends string = string> = {
+    defaultOfferKey: TOfferKey;
+    defaultOfferOrder: readonly TOfferKey[];
+    countryOverrides?: Record<string, CountryPricingOverride<TOfferKey>>;
+};
+export type ResolvedCountryPricing<TOfferKey extends string = string> = {
+    countryCode: string | null;
+    defaultOfferKey: TOfferKey;
+    offerOrder: readonly TOfferKey[];
+};
+export type StepEditorFieldKind = 'text' | 'textLines' | 'textarea' | 'image' | 'boolean' | 'select' | 'list' | 'pricingProfile';
+export type StepEditorListPreset = 'choiceItems' | 'infoItems' | 'quoteItems' | 'imageItems' | 'qaItems' | 'linkItems' | 'reasonItems' | 'storeLinkItems' | 'planPresentationItems';
+export type StepEditorSelectOption = {
+    label: string;
+    value: string;
+};
+export type StepEditorFieldVariableSource = 'plan' | 'user';
+export type StepEditorVariableMapping = {
+    id: string;
+    label: string;
+    token: `user.${string}`;
+    sourcePath: string;
+};
+export type StepEditorField = {
+    id: string;
+    label: string;
+    kind: StepEditorFieldKind;
+    path: string;
+    supportsVariables?: boolean;
+    variableSources?: readonly StepEditorFieldVariableSource[];
+    preset?: StepEditorListPreset;
+    options?: readonly StepEditorSelectOption[];
+};
+export type StepEditorSection = {
+    id: string;
+    label: string;
+    variables?: readonly StepEditorVariableMapping[];
+    fields: readonly StepEditorField[];
+};
+export declare function validateStepContentDefinition<TLocaleContent, TLocaleCode extends string = string>(definition: LocalizedStepContent<TLocaleContent, TLocaleCode>): LocalizedStepContent<TLocaleContent, TLocaleCode>;
+export declare function validateCountryPricingProfile<TOfferKey extends string>(profile: CountryPricingProfile<TOfferKey>): CountryPricingProfile<TOfferKey>;
+export declare function normalizeCountryPricingProfile<TOfferKey extends string>(profile: CountryPricingProfile<TOfferKey>): CountryPricingProfile<TOfferKey>;
+export declare function validateStepEditorSections(sections: readonly StepEditorSection[]): readonly StepEditorSection[];
+export declare const resolveUniversalContentVariables: <TContent>(content: TContent, variables: Record<string, string>) => TContent;
+export declare const collectStepEditorVariables: (sections: readonly StepEditorSection[]) => readonly StepEditorVariableMapping[];
+export declare const resolveStepEditorUserVariableValues: (sections: readonly StepEditorSection[], answers: Record<string, unknown>) => Record<string, string>;
+export declare const resolveStepContentVariables: <TContent extends Record<string, unknown>>(content: TContent, sections: readonly StepEditorSection[], variables: Record<string, string>) => TContent;
+export declare function resolveLocalizedStepContent<TLocaleContent>(definition: LocalizedStepContent<TLocaleContent>, requestedLocale?: string | null): TLocaleContent;
+export declare function resolveCountryPricing<TOfferKey extends string>(profile: CountryPricingProfile<TOfferKey>, requestedCountryCode?: string | null): ResolvedCountryPricing<TOfferKey>;

package/dist/content/step-content.js

@@ -0,0 +1,381 @@
+const PREVIEW_DEFINITION_OVERRIDE_STORE_KEY = '__funnelsgrovePreviewDefinitionOverrides';
+const isValidFieldKind = (value) => {
+    return (value === 'text' ||
+        value === 'textLines' ||
+        value === 'textarea' ||
+        value === 'image' ||
+        value === 'boolean' ||
+        value === 'select' ||
+        value === 'list' ||
+        value === 'pricingProfile');
+};
+const isValidListPreset = (value) => {
+    return (value === 'choiceItems' ||
+        value === 'infoItems' ||
+        value === 'quoteItems' ||
+        value === 'imageItems' ||
+        value === 'qaItems' ||
+        value === 'linkItems' ||
+        value === 'reasonItems' ||
+        value === 'storeLinkItems' ||
+        value === 'planPresentationItems');
+};
+const isValidVariableSource = (value) => {
+    return value === 'plan' || value === 'user';
+};
+const isObjectRecord = (value) => {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+};
+export function validateStepContentDefinition(definition) {
+    const localeEntries = Object.entries(definition.locales);
+    if (localeEntries.length === 0) {
+        throw new Error('Step content definition requires at least one locale.');
+    }
+    const normalizedDefaultLocale = normalizeLocaleCode(definition.defaultLocale);
+    if (!normalizedDefaultLocale) {
+        throw new Error('Step content definition requires a valid default locale.');
+    }
+    const hasDefaultLocale = localeEntries.some(([localeCode]) => normalizeLocaleCode(localeCode) === normalizedDefaultLocale);
+    if (!hasDefaultLocale) {
+        throw new Error('Step content definition requires the default locale to exist in locales.');
+    }
+    return definition;
+}
+export function validateCountryPricingProfile(profile) {
+    var _a;
+    if (profile.defaultOfferOrder.length === 0) {
+        throw new Error('Country pricing profile requires at least one default offer.');
+    }
+    if (!profile.defaultOfferOrder.includes(profile.defaultOfferKey)) {
+        throw new Error('Country pricing profile default offer must exist in the default order.');
+    }
+    for (const [countryCode, override] of Object.entries((_a = profile.countryOverrides) !== null && _a !== void 0 ? _a : {})) {
+        if (!normalizeCountryCode(countryCode)) {
+            throw new Error(`Country pricing profile contains an invalid country code: ${countryCode}`);
+        }
+        if (override.defaultOfferKey &&
+            override.offerOrder &&
+            !override.offerOrder.includes(override.defaultOfferKey)) {
+            throw new Error(`Country pricing override default offer must exist in the offer order for ${countryCode}.`);
+        }
+    }
+    return profile;
+}
+const normalizeOfferKeyList = (value) => {
+    return Array.from(new Set((value !== null && value !== void 0 ? value : [])
+        .map((offerKey) => `${offerKey}`.trim())
+        .filter(Boolean)));
+};
+const normalizeOfferKey = (value) => {
+    return (value ? `${value}`.trim() : '');
+};
+export function normalizeCountryPricingProfile(profile) {
+    var _a, _b, _c;
+    let defaultOfferOrder = normalizeOfferKeyList(profile.defaultOfferOrder);
+    let defaultOfferKey = normalizeOfferKey(profile.defaultOfferKey);
+    if (!defaultOfferKey && defaultOfferOrder.length > 0) {
+        defaultOfferKey = (_a = defaultOfferOrder[0]) !== null && _a !== void 0 ? _a : '';
+    }
+    if (defaultOfferKey && !defaultOfferOrder.includes(defaultOfferKey)) {
+        defaultOfferOrder = [defaultOfferKey, ...defaultOfferOrder];
+    }
+    if (defaultOfferOrder.length === 0 && defaultOfferKey) {
+        defaultOfferOrder = [defaultOfferKey];
+    }
+    if (defaultOfferOrder.length === 0) {
+        defaultOfferOrder = ['default'];
+    }
+    if (!defaultOfferKey) {
+        defaultOfferKey = (_b = defaultOfferOrder[0]) !== null && _b !== void 0 ? _b : 'default';
+    }
+    const normalizedOverrides = Object.fromEntries(Object.entries((_c = profile.countryOverrides) !== null && _c !== void 0 ? _c : {}).flatMap(([countryCodeRaw, overrideRaw]) => {
+        var _a;
+        const countryCode = normalizeCountryCode(countryCodeRaw);
+        if (!countryCode) {
+            return [];
+        }
+        const override = overrideRaw !== null && overrideRaw !== void 0 ? overrideRaw : {};
+        const hasExplicitOfferOrder = Array.isArray(override.offerOrder) && override.offerOrder.length > 0;
+        let offerOrder = normalizeOfferKeyList(override.offerOrder);
+        let offerKey = normalizeOfferKey(override.defaultOfferKey);
+        if (!offerKey && offerOrder.length > 0) {
+            offerKey = (_a = offerOrder[0]) !== null && _a !== void 0 ? _a : '';
+        }
+        if (offerKey && hasExplicitOfferOrder && !offerOrder.includes(offerKey)) {
+            offerOrder = [offerKey, ...offerOrder];
+        }
+        return [
+            [
+                countryCode,
+                Object.assign(Object.assign({}, (offerKey ? { defaultOfferKey: offerKey } : {})), (hasExplicitOfferOrder && offerOrder.length > 0 ? { offerOrder } : {})),
+            ],
+        ];
+    }));
+    return {
+        defaultOfferKey: defaultOfferKey,
+        defaultOfferOrder,
+        countryOverrides: normalizedOverrides,
+    };
+}
+export function validateStepEditorSections(sections) {
+    var _a, _b, _c;
+    if (sections.length === 0) {
+        throw new Error('Step editor definition requires at least one section.');
+    }
+    for (const section of sections) {
+        if (!section.id.trim() || !section.label.trim()) {
+            throw new Error('Step editor sections require non-empty ids and labels.');
+        }
+        if (section.fields.length === 0) {
+            throw new Error(`Step editor section "${section.id}" requires at least one field.`);
+        }
+        for (const field of section.fields) {
+            if (!field.id.trim() || !field.label.trim() || !field.path.trim()) {
+                throw new Error(`Step editor field in section "${section.id}" is missing required text.`);
+            }
+            if (!isValidFieldKind(field.kind)) {
+                throw new Error(`Unsupported step editor field kind: ${String(field.kind)}`);
+            }
+            if (field.kind === 'list' && !isValidListPreset(field.preset)) {
+                throw new Error(`List field "${field.id}" requires a valid list preset.`);
+            }
+            if (field.kind === 'select') {
+                const options = (_a = field.options) !== null && _a !== void 0 ? _a : [];
+                if (options.length === 0) {
+                    throw new Error(`Select field "${field.id}" requires at least one option.`);
+                }
+            }
+            if (field.supportsVariables) {
+                if (field.kind !== 'text' && field.kind !== 'textLines' && field.kind !== 'textarea') {
+                    throw new Error(`Only text-capable fields can enable variables: ${field.id}`);
+                }
+                const variableSources = (_b = field.variableSources) !== null && _b !== void 0 ? _b : ['plan', 'user'];
+                if (variableSources.length === 0 || variableSources.some((value) => !isValidVariableSource(value))) {
+                    throw new Error(`Variable-enabled field "${field.id}" requires valid variable sources.`);
+                }
+            }
+        }
+        for (const variable of (_c = section.variables) !== null && _c !== void 0 ? _c : []) {
+            if (!variable.id.trim() || !variable.label.trim() || !variable.sourcePath.trim()) {
+                throw new Error(`Step editor variable in section "${section.id}" is missing required text.`);
+            }
+            if (!variable.token.startsWith('user.')) {
+                throw new Error(`Step editor variable "${variable.id}" must use a user.* token.`);
+            }
+        }
+    }
+    return sections;
+}
+const readValueAtPath = (value, path) => {
+    if (!path.trim()) {
+        return value;
+    }
+    return path.split('.').reduce((currentValue, segment) => {
+        if (!isObjectRecord(currentValue) || !segment) {
+            return undefined;
+        }
+        return currentValue[segment];
+    }, value);
+};
+const updateValueAtPath = (value, path, nextValue) => {
+    const segments = path.split('.').filter(Boolean);
+    if (segments.length === 0) {
+        return nextValue;
+    }
+    const [head, ...tail] = segments;
+    const currentRecord = isObjectRecord(value) ? value : {};
+    if (tail.length === 0) {
+        return Object.assign(Object.assign({}, currentRecord), { [head]: nextValue });
+    }
+    return Object.assign(Object.assign({}, currentRecord), { [head]: updateValueAtPath(currentRecord[head], tail.join('.'), nextValue) });
+};
+const VARIABLE_TOKEN_PATTERN = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
+const interpolateVariableString = (value, variables) => {
+    return value.replace(VARIABLE_TOKEN_PATTERN, (_, rawToken) => {
+        var _a;
+        const token = rawToken.trim();
+        return (_a = variables[token]) !== null && _a !== void 0 ? _a : '';
+    });
+};
+const UNIVERSAL_VARIABLE_TOKEN_PATTERN = /\{([a-zA-Z0-9_.-]+)\}/g;
+const interpolateUniversalVariableString = (value, variables) => {
+    return value.replace(UNIVERSAL_VARIABLE_TOKEN_PATTERN, (match, rawToken) => {
+        var _a;
+        const token = rawToken.trim();
+        return token in variables ? (_a = variables[token]) !== null && _a !== void 0 ? _a : '' : match;
+    });
+};
+export const resolveUniversalContentVariables = (content, variables) => {
+    if (typeof content === 'string') {
+        return interpolateUniversalVariableString(content, variables);
+    }
+    if (Array.isArray(content)) {
+        return content.map((item) => resolveUniversalContentVariables(item, variables));
+    }
+    if (isObjectRecord(content)) {
+        return Object.fromEntries(Object.entries(content).map(([key, value]) => [
+            key,
+            resolveUniversalContentVariables(value, variables),
+        ]));
+    }
+    return content;
+};
+export const collectStepEditorVariables = (sections) => {
+    return sections.flatMap((section) => { var _a; return (_a = section.variables) !== null && _a !== void 0 ? _a : []; });
+};
+export const resolveStepEditorUserVariableValues = (sections, answers) => {
+    return Object.fromEntries(collectStepEditorVariables(sections).flatMap((mapping) => {
+        const rawValue = readValueAtPath(answers, mapping.sourcePath);
+        if (typeof rawValue === 'string') {
+            return [[mapping.token, rawValue]];
+        }
+        if (Array.isArray(rawValue)) {
+            const labels = rawValue
+                .map((item) => (typeof item === 'string' ? item.trim() : ''))
+                .filter(Boolean);
+            return labels.length > 0 ? [[mapping.token, labels.join(' + ')]] : [];
+        }
+        if (typeof rawValue === 'number' || typeof rawValue === 'boolean') {
+            return [[mapping.token, String(rawValue)]];
+        }
+        return [];
+    }));
+};
+export const resolveStepContentVariables = (content, sections, variables) => {
+    let nextContent = content;
+    for (const section of sections) {
+        for (const field of section.fields) {
+            if (!field.supportsVariables) {
+                continue;
+            }
+            const currentValue = readValueAtPath(nextContent, field.path);
+            if (typeof currentValue === 'string') {
+                nextContent = updateValueAtPath(nextContent, field.path, interpolateVariableString(currentValue, variables));
+                continue;
+            }
+            if (field.kind === 'textLines' && Array.isArray(currentValue)) {
+                nextContent = updateValueAtPath(nextContent, field.path, currentValue.map((line) => typeof line === 'string' ? interpolateVariableString(line, variables) : line));
+            }
+        }
+    }
+    return nextContent;
+};
+const normalizeLocaleCode = (localeCode) => {
+    if (typeof localeCode !== 'string') {
+        return null;
+    }
+    const trimmed = localeCode.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return trimmed.replace(/_/g, '-').toLowerCase();
+};
+const normalizeCountryCode = (countryCode) => {
+    if (typeof countryCode !== 'string') {
+        return null;
+    }
+    const trimmed = countryCode.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return trimmed.toUpperCase();
+};
+const getPreviewDefinitionOverrideState = () => {
+    var _a;
+    const globalStore = globalThis[PREVIEW_DEFINITION_OVERRIDE_STORE_KEY];
+    return (_a = globalStore === null || globalStore === void 0 ? void 0 : globalStore.state) !== null && _a !== void 0 ? _a : null;
+};
+const getPreviewStepIdFromWindowLocation = () => {
+    if (typeof window === 'undefined') {
+        return null;
+    }
+    const stepFromSearch = (() => {
+        try {
+            const value = new URLSearchParams(window.location.search).get('step');
+            return typeof value === 'string' ? value.trim() : '';
+        }
+        catch (_a) {
+            return '';
+        }
+    })();
+    if (stepFromSearch) {
+        return stepFromSearch;
+    }
+    const pathSegments = window.location.pathname.split('/').filter(Boolean);
+    if (pathSegments[0] === 'builder-preview' && pathSegments[2]) {
+        return pathSegments[2];
+    }
+    if (pathSegments[0] === 'published' && pathSegments[1] === 'f' && pathSegments[3]) {
+        return pathSegments[3];
+    }
+    if (pathSegments[0] === 'preview' && pathSegments[1] === 's' && pathSegments[3]) {
+        return pathSegments[3];
+    }
+    return null;
+};
+export function resolveLocalizedStepContent(definition, requestedLocale) {
+    var _a;
+    const validatedDefinition = validateStepContentDefinition(definition);
+    const entries = Object.entries(validatedDefinition.locales);
+    const previewStepId = getPreviewStepIdFromWindowLocation();
+    const previewStepOverrides = previewStepId && ((_a = getPreviewDefinitionOverrideState()) === null || _a === void 0 ? void 0 : _a.contentByStepId[previewStepId])
+        ? getPreviewDefinitionOverrideState().contentByStepId[previewStepId]
+        : null;
+    const normalizedRequestedLocale = normalizeLocaleCode(requestedLocale);
+    const localeMap = new Map();
+    for (const [localeCode, localeContent] of entries) {
+        const normalizedLocale = normalizeLocaleCode(localeCode);
+        if (!normalizedLocale) {
+            continue;
+        }
+        localeMap.set(normalizedLocale, localeContent);
+    }
+    if (previewStepOverrides) {
+        for (const [localeCode, localeContent] of Object.entries(previewStepOverrides)) {
+            const normalizedLocale = normalizeLocaleCode(localeCode);
+            if (!normalizedLocale) {
+                continue;
+            }
+            localeMap.set(normalizedLocale, localeContent);
+        }
+    }
+    if (normalizedRequestedLocale) {
+        const exactMatch = localeMap.get(normalizedRequestedLocale);
+        if (exactMatch) {
+            return exactMatch;
+        }
+        const baseLocale = normalizedRequestedLocale.split('-')[0];
+        if (baseLocale) {
+            const baseMatch = localeMap.get(baseLocale);
+            if (baseMatch) {
+                return baseMatch;
+            }
+        }
+    }
+    const normalizedDefaultLocale = normalizeLocaleCode(validatedDefinition.defaultLocale);
+    if (normalizedDefaultLocale) {
+        const defaultMatch = localeMap.get(normalizedDefaultLocale);
+        if (defaultMatch) {
+            return defaultMatch;
+        }
+    }
+    return entries[0][1];
+}
+export function resolveCountryPricing(profile, requestedCountryCode) {
+    var _a, _b, _c, _d;
+    const previewStepId = getPreviewStepIdFromWindowLocation();
+    const previewPricingOverride = previewStepId && ((_a = getPreviewDefinitionOverrideState()) === null || _a === void 0 ? void 0 : _a.pricingByStepId[previewStepId])
+        ? getPreviewDefinitionOverrideState().pricingByStepId[previewStepId]
+        : null;
+    const validatedProfile = validateCountryPricingProfile(normalizeCountryPricingProfile(previewPricingOverride || profile));
+    const countryCode = normalizeCountryCode(requestedCountryCode);
+    const overrideEntry = countryCode
+        ? Object.entries((_b = validatedProfile.countryOverrides) !== null && _b !== void 0 ? _b : {}).find(([overrideCountryCode]) => normalizeCountryCode(overrideCountryCode) === countryCode)
+        : null;
+    const override = overrideEntry === null || overrideEntry === void 0 ? void 0 : overrideEntry[1];
+    return {
+        countryCode,
+        defaultOfferKey: (_c = override === null || override === void 0 ? void 0 : override.defaultOfferKey) !== null && _c !== void 0 ? _c : validatedProfile.defaultOfferKey,
+        offerOrder: (_d = override === null || override === void 0 ? void 0 : override.offerOrder) !== null && _d !== void 0 ? _d : validatedProfile.defaultOfferOrder,
+    };
+}

package/dist/index.d.ts

@@ -1,21 +1,33 @@
-export * from './config/builder-preview.protocol';
-export * from './config/funnel.manifest.types';
-export * from './config/funnel-theme';
-export * from './runtime/experiment-assignment';
-export * from './runtime/browser-helpers';
-export * from './runtime/funnel-flow';
-export * from './runtime/funnel-manifest.validation';
-export * from './runtime/funnel-runtime';
-export * from './runtime/use-funnel-flow-controller';
-export * from './runtime/preview-bridge';
-export * from './runtime/route-resolver';
-export * from './services/api.service';
-export * from './services/logger';
-export * from './services/preview-frame.service';
-export * from './services/runtime-api.config';
-export * from './services/runtime-mode.service';
-export * from './sdk/userAnswers';
-export * from './components/FunnelContext';
-export * from './components/FunnelEditorPanel';
-export * from './components/shared/PrimaryButton';
-export * from './steps/types';
+export * from './config/builder-preview.protocol.js';
+export * from './config/env.config.js';
+export * from './config/funnel.manifest.types.js';
+export * from './config/funnel-theme.js';
+export * from './config/font-config.js';
+export * from './content/step-content.js';
+export * from './runtime/experiment-assignment.js';
+export * from './runtime/browser-helpers.js';
+export * from './runtime/funnel-flow.js';
+export * from './runtime/funnel-attribution.js';
+export * from './runtime/funnel-manifest.validation.js';
+export * from './runtime/funnel-runtime.js';
+export * from './runtime/posthog-flags.js';
+export * from './runtime/use-funnel-flow-controller.js';
+export * from './runtime/preview-bridge.js';
+export * from './runtime/preview-definition-overrides.js';
+export * from './runtime/route-resolver.js';
+export * from './runtime/subscription-handoff.js';
+export * from './services/api.service.js';
+export * from './services/funnel-state.service.js';
+export * from './services/logger.js';
+export * from './services/preview-frame.service.js';
+export * from './services/public-env.js';
+export * from './services/runtime-api.config.js';
+export * from './services/runtime-mode.service.js';
+export * from './sdk/userAnswers.js';
+export * from './components/FunnelContext.js';
+export * from './components/FunnelEditorPanel.js';
+export * from './components/ManageSubscriptionScreen.js';
+export * from './components/RuntimeDevInfoBox.js';
+export * from './components/SubscriptionHandoffScreen.js';
+export * from './components/shared/PrimaryButton.js';
+export * from './steps/types.js';

package/dist/index.js

@@ -1,21 +1,33 @@
-export * from './config/builder-preview.protocol';
-export * from './config/funnel.manifest.types';
-export * from './config/funnel-theme';
-export * from './runtime/experiment-assignment';
-export * from './runtime/browser-helpers';
-export * from './runtime/funnel-flow';
-export * from './runtime/funnel-manifest.validation';
-export * from './runtime/funnel-runtime';
-export * from './runtime/use-funnel-flow-controller';
-export * from './runtime/preview-bridge';
-export * from './runtime/route-resolver';
-export * from './services/api.service';
-export * from './services/logger';
-export * from './services/preview-frame.service';
-export * from './services/runtime-api.config';
-export * from './services/runtime-mode.service';
-export * from './sdk/userAnswers';
-export * from './components/FunnelContext';
-export * from './components/FunnelEditorPanel';
-export * from './components/shared/PrimaryButton';
-export * from './steps/types';
+export * from './config/builder-preview.protocol.js';
+export * from './config/env.config.js';
+export * from './config/funnel.manifest.types.js';
+export * from './config/funnel-theme.js';
+export * from './config/font-config.js';
+export * from './content/step-content.js';
+export * from './runtime/experiment-assignment.js';
+export * from './runtime/browser-helpers.js';
+export * from './runtime/funnel-flow.js';
+export * from './runtime/funnel-attribution.js';
+export * from './runtime/funnel-manifest.validation.js';
+export * from './runtime/funnel-runtime.js';
+export * from './runtime/posthog-flags.js';
+export * from './runtime/use-funnel-flow-controller.js';
+export * from './runtime/preview-bridge.js';
+export * from './runtime/preview-definition-overrides.js';
+export * from './runtime/route-resolver.js';
+export * from './runtime/subscription-handoff.js';
+export * from './services/api.service.js';
+export * from './services/funnel-state.service.js';
+export * from './services/logger.js';
+export * from './services/preview-frame.service.js';
+export * from './services/public-env.js';
+export * from './services/runtime-api.config.js';
+export * from './services/runtime-mode.service.js';
+export * from './sdk/userAnswers.js';
+export * from './components/FunnelContext.js';
+export * from './components/FunnelEditorPanel.js';
+export * from './components/ManageSubscriptionScreen.js';
+export * from './components/RuntimeDevInfoBox.js';
+export * from './components/SubscriptionHandoffScreen.js';
+export * from './components/shared/PrimaryButton.js';
+export * from './steps/types.js';

package/dist/runtime/browser-helpers.d.ts

@@ -1,6 +1,7 @@
 export declare const canUseDom: () => boolean;
 export declare const readWindowStorageValue: (storageKey: string) => string | null;
 export declare const writeWindowStorageValue: (storageKey: string, value: string) => void;
+export declare const removeWindowStorageValue: (storageKey: string) => void;
 export declare const dispatchWindowCustomEvent: <Detail>(eventType: string, detail: Detail) => void;
 export declare const buildHostedStepLocation: (input: {
     currentHref: string;

package/dist/runtime/browser-helpers.js

@@ -23,6 +23,17 @@ export const writeWindowStorageValue = (storageKey, value) => {
         // ignore storage access failures
     }
 };
+export const removeWindowStorageValue = (storageKey) => {
+    if (!canUseDom()) {
+        return;
+    }
+    try {
+        window.localStorage.removeItem(storageKey);
+    }
+    catch (_a) {
+        // ignore storage access failures
+    }
+};
 export const dispatchWindowCustomEvent = (eventType, detail) => {
     if (!canUseDom()) {
         return;
@@ -42,6 +53,9 @@ const getHostedFunnelBaseSegments = (pathname) => {
     if (pathSegments[0] === 'catalog' && pathSegments[1]) {
         return pathSegments.slice(0, 2);
     }
+    if (pathSegments[0] === 'builder-preview' && pathSegments[1]) {
+        return pathSegments.slice(0, 2);
+    }
     return [];
 };
 export const buildHostedStepLocation = (input) => {