@funnelsgrove/runtime 0.1.48 → 0.1.49

package/dist/runtime/experiment-assignment.d.ts

@@ -10,4 +10,5 @@ export type Assignment = {
     variantKey: string;
     routeToStepId: string;
 };
+export declare const resolveForcedExperimentAssignment: (input: ResolveInput) => Assignment | null;
 export declare const resolveExperimentAssignment: (input: ResolveInput) => Assignment | null;

package/dist/runtime/experiment-assignment.js

@@ -16,14 +16,21 @@ const resolveForcedVariant = (input) => {
         return null;
     }
 };
+export const resolveForcedExperimentAssignment = (input) => {
+    const forcedVariant = resolveForcedVariant(input);
+    if (!forcedVariant) {
+        return null;
+    }
+    return { variantKey: forcedVariant.variantKey, routeToStepId: forcedVariant.routeToStepId };
+};
 export const resolveExperimentAssignment = (input) => {
     var _a;
     if (input.variants.length === 0) {
         return null;
     }
-    const forcedVariant = resolveForcedVariant(input);
-    if (forcedVariant) {
-        return { variantKey: forcedVariant.variantKey, routeToStepId: forcedVariant.routeToStepId };
+    const forcedAssignment = resolveForcedExperimentAssignment(input);
+    if (forcedAssignment) {
+        return forcedAssignment;
     }
     const resolved = resolveExperimentVariant(input.experimentId);
     const match = resolved ? input.variants.find((variant) => variant.variantKey === resolved) : undefined;

package/dist/runtime/use-funnel-flow-controller.d.ts

@@ -116,8 +116,15 @@ export declare function computeRenderSuspended(input: {
     postHogReady: boolean;
     experiments: ReadonlyArray<{
         stepId: string;
-    }>;
+    } & Partial<Pick<FunnelManifestExperiment, 'experimentId' | 'variants'>>>;
     isPreviewRuntime?: boolean;
 }): boolean;
+export declare function resolveRenderedExperimentStepId(input: {
+    activeExperiment: FunnelManifestExperiment | null;
+    editorVariantOverrides: Record<string, string>;
+    postHogReady: boolean;
+    resolveRenderableStepId: (stepId: string | null | undefined) => string | null;
+    safeActiveStepId: string;
+}): string;
 export declare function useFunnelFlowController<StepId extends string>({ analytics, initialStepId, initialAttributes, lockToInitialStep, defaultStepId, stepSequence, stepById, stepComponentById, funnelExperiments, getPathForStep, getStepIdFromPath, getSequentialNextStepId, getChoiceTargetsForStep, isFunnelStepId, resolveConfiguredNextStep, resolveRuntimeInitialStepId, }: UseFunnelFlowControllerInput<StepId>): UseFunnelFlowControllerResult<StepId>;
 export {};

package/dist/runtime/use-funnel-flow-controller.js

@@ -7,7 +7,7 @@ import { FUNNEL_ID, POSTHOG_API_HOST, POSTHOG_PROJECT_API_KEY, PROJECT_ID, } fro
 import { buildHostedStepLocation, dispatchWindowCustomEvent, } from './browser-helpers.js';
 import { isPreviewStepLockRequested, resolveNextStepFromContext, shouldRunAutoAdvanceTimer, } from './funnel-flow.js';
 import { usePreviewBridge } from './preview-bridge.js';
-import { resolveExperimentAssignment } from './experiment-assignment.js';
+import { resolveExperimentAssignment, resolveForcedExperimentAssignment, } from './experiment-assignment.js';
 import { collectCurrentFunnelAttribution } from './funnel-attribution.js';
 import { resolveUrlUserAttributes } from './url-user-attributes.js';
 import { bootstrapPostHog, identifyPostHog, isPostHogReady, resolveExperimentVariant, } from './posthog-flags.js';
@@ -15,10 +15,56 @@ import { getRuntimeMode, isEditorEnabled, useRuntimeMode } from '../services/run
 import { isPreviewFrameRuntime } from '../services/preview-frame.service.js';
 const FIRST_STEP_ENGAGEMENT_THRESHOLD_MS = 1000;
 export function computeRenderSuspended(input) {
+    var _a;
     if (input.isPreviewRuntime || input.postHogReady) {
         return false;
     }
-    return input.experiments.some((experiment) => experiment.stepId === input.activeStepId);
+    const activeExperiment = input.experiments.find((experiment) => experiment.stepId === input.activeStepId);
+    if (!activeExperiment) {
+        return false;
+    }
+    if (activeExperiment.experimentId && ((_a = activeExperiment.variants) === null || _a === void 0 ? void 0 : _a.length)) {
+        const forcedAssignment = resolveForcedExperimentAssignment({
+            experimentId: activeExperiment.experimentId,
+            variants: activeExperiment.variants,
+        });
+        if (forcedAssignment) {
+            return false;
+        }
+    }
+    return true;
+}
+export function resolveRenderedExperimentStepId(input) {
+    const { activeExperiment, editorVariantOverrides, postHogReady, resolveRenderableStepId, safeActiveStepId, } = input;
+    if (!activeExperiment) {
+        return safeActiveStepId;
+    }
+    const override = editorVariantOverrides[activeExperiment.experimentId];
+    if (override) {
+        const matchedVariant = activeExperiment.variants.find((variant) => variant.variantKey === override);
+        const variantStepId = resolveRenderableStepId((matchedVariant === null || matchedVariant === void 0 ? void 0 : matchedVariant.routeToStepId) || null);
+        return variantStepId !== null && variantStepId !== void 0 ? variantStepId : safeActiveStepId;
+    }
+    const forcedAssignment = resolveForcedExperimentAssignment({
+        experimentId: activeExperiment.experimentId,
+        variants: activeExperiment.variants,
+    });
+    if (forcedAssignment) {
+        const forcedStepId = resolveRenderableStepId(forcedAssignment.routeToStepId);
+        return forcedStepId !== null && forcedStepId !== void 0 ? forcedStepId : safeActiveStepId;
+    }
+    if (!postHogReady) {
+        return safeActiveStepId;
+    }
+    const assignment = resolveExperimentAssignment({
+        experimentId: activeExperiment.experimentId,
+        variants: activeExperiment.variants,
+    });
+    if (!assignment) {
+        return safeActiveStepId;
+    }
+    const variantStepId = resolveRenderableStepId(assignment.routeToStepId);
+    return variantStepId !== null && variantStepId !== void 0 ? variantStepId : safeActiveStepId;
 }
 export function useFunnelFlowController({ analytics, initialStepId, initialAttributes, lockToInitialStep = false, defaultStepId, stepSequence, stepById, stepComponentById, funnelExperiments, getPathForStep, getStepIdFromPath, getSequentialNextStepId, getChoiceTargetsForStep, isFunnelStepId, resolveConfiguredNextStep, resolveRuntimeInitialStepId, }) {
     var _a, _b;
@@ -92,35 +138,26 @@ export function useFunnelFlowController({ analytics, initialStepId, initialAttri
         if (override) {
             return override;
         }
+        const forcedAssignment = resolveForcedExperimentAssignment({
+            experimentId: experiment.experimentId,
+            variants: experiment.variants,
+        });
+        if (forcedAssignment) {
+            return forcedAssignment.variantKey;
+        }
         if (!postHogReady) {
             return null;
         }
         return (_a = resolveExperimentVariant(experiment.experimentId)) !== null && _a !== void 0 ? _a : null;
     }, [editorVariantOverrides, postHogReady]);
     const activeExperimentForStep = useMemo(() => funnelExperiments.find((candidate) => candidate.stepId === safeActiveStepId) || null, [funnelExperiments, safeActiveStepId]);
-    const renderedStepId = useMemo(() => {
-        if (!activeExperimentForStep) {
-            return safeActiveStepId;
-        }
-        const override = editorVariantOverrides[activeExperimentForStep.experimentId];
-        if (override) {
-            const matchedVariant = activeExperimentForStep.variants.find((variant) => variant.variantKey === override);
-            const variantStepId = resolveRenderableStepId((matchedVariant === null || matchedVariant === void 0 ? void 0 : matchedVariant.routeToStepId) || null);
-            return variantStepId !== null && variantStepId !== void 0 ? variantStepId : safeActiveStepId;
-        }
-        if (!postHogReady) {
-            return safeActiveStepId;
-        }
-        const assignment = resolveExperimentAssignment({
-            experimentId: activeExperimentForStep.experimentId,
-            variants: activeExperimentForStep.variants,
-        });
-        if (!assignment) {
-            return safeActiveStepId;
-        }
-        const variantStepId = resolveRenderableStepId(assignment.routeToStepId);
-        return variantStepId !== null && variantStepId !== void 0 ? variantStepId : safeActiveStepId;
-    }, [activeExperimentForStep, editorVariantOverrides, postHogReady, resolveRenderableStepId, safeActiveStepId]);
+    const renderedStepId = useMemo(() => resolveRenderedExperimentStepId({
+        activeExperiment: activeExperimentForStep,
+        editorVariantOverrides,
+        postHogReady,
+        resolveRenderableStepId,
+        safeActiveStepId,
+    }), [activeExperimentForStep, editorVariantOverrides, postHogReady, resolveRenderableStepId, safeActiveStepId]);
     const renderedStepMeta = stepById[renderedStepId];
     const activeStepComponent = stepComponentById[renderedStepId];
     const postHogFeatureFlags = useMemo(() => {
@@ -584,6 +621,13 @@ export function useFunnelFlowController({ analytics, initialStepId, initialAttri
         if (override) {
             return override;
         }
+        const forcedAssignment = resolveForcedExperimentAssignment({
+            experimentId: experiment.experimentId,
+            variants: experiment.variants,
+        });
+        if (forcedAssignment) {
+            return forcedAssignment.variantKey;
+        }
         if (postHogReady) {
             const assignment = resolveExperimentAssignment({
                 experimentId: experiment.experimentId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funnelsgrove/runtime",
-  "version": "0.1.48",
+  "version": "0.1.49",
   "type": "module",
   "private": false,
   "main": "./dist/index.js",