@funnelsgrove/runtime 0.1.48 → 0.1.50

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/funnel-runtime.d.ts

@@ -7,6 +7,7 @@ export type FunnelStepOrderGraph = {
     entryPointStepIds?: readonly string[];
     edgesByStepId?: Partial<Record<string, readonly {
         toStepId: string;
+        conditionId?: string | null;
     }[]>>;
 };
 export declare const getFunnelStepSequence: (manifest: FunnelManifest) => FunnelStepId[];

package/dist/runtime/funnel-runtime.js

@@ -17,7 +17,10 @@ export const getFunnelStepIdsByEdgeOrder = (graph) => {
         }
         visitedStepIds.add(stepId);
         orderedStepIds.push(stepId);
-        for (const edge of ((_a = graph.edgesByStepId) === null || _a === void 0 ? void 0 : _a[stepId]) || []) {
+        const edges = [...(((_a = graph.edgesByStepId) === null || _a === void 0 ? void 0 : _a[stepId]) || [])].sort((left, right) => {
+            return Number(Boolean(left.conditionId)) - Number(Boolean(right.conditionId));
+        });
+        for (const edge of edges) {
             visit(edge.toStepId);
         }
     };

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

@@ -31,18 +31,6 @@ type FunnelFlowAnalyticsAdapter = {
         selected?: Record<string, unknown>;
         featureFlags?: Record<string, string>;
     }) => string | null;
-    trackStepEngaged?: (input: {
-        userId?: string;
-        environment?: 'test' | 'live';
-        stepId: string;
-        stepName: string;
-        stepType?: string;
-        startedAt: string;
-        engagedAt: string;
-        durationMs: number;
-        engagementThresholdMs: number;
-        featureFlags?: Record<string, string>;
-    }) => string | null;
     trackFunnelStarted?: (input: {
         userId?: string;
         environment?: 'test' | 'live';
@@ -116,8 +104,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,18 +7,63 @@ 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';
 import { getRuntimeMode, isEditorEnabled, useRuntimeMode } from '../services/runtime-mode.service.js';
 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;
@@ -75,8 +120,6 @@ export function useFunnelFlowController({ analytics, initialStepId, initialAttri
     const prevStepIdRef = useRef(null);
     const firstStepViewedTrackedRef = useRef(false);
     const stepStartedAtByIdRef = useRef({});
-    const engagedStepIdsRef = useRef(new Set());
-    const firstStepEngagementTimerRef = useRef(null);
     const currentUserIdRef = useRef(user.id);
     const safeActiveStepId = useMemo(() => { var _a; return (_a = resolveRenderableStepId(activeStepId)) !== null && _a !== void 0 ? _a : safeInitialStepId; }, [activeStepId, resolveRenderableStepId, safeInitialStepId]);
     const activeStepMeta = stepById[safeActiveStepId];
@@ -92,35 +135,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(() => {
@@ -416,37 +450,6 @@ export function useFunnelFlowController({ analytics, initialStepId, initialAttri
                     occurredAt: startedAt,
                     featureFlags: postHogFeatureFlagsRef.current,
                 });
-                if (!engagedStepIdsRef.current.has(renderedStepId)) {
-                    if (firstStepEngagementTimerRef.current !== null) {
-                        window.clearTimeout(firstStepEngagementTimerRef.current);
-                    }
-                    const engagedStepId = renderedStepId;
-                    const engagedStartedAt = startedAt;
-                    const engagedStepName = stepName;
-                    const engagedStepType = stepType;
-                    firstStepEngagementTimerRef.current = window.setTimeout(() => {
-                        var _a;
-                        firstStepEngagementTimerRef.current = null;
-                        if (prevStepIdRef.current !== engagedStepId ||
-                            engagedStepIdsRef.current.has(engagedStepId)) {
-                            return;
-                        }
-                        engagedStepIdsRef.current.add(engagedStepId);
-                        const engagedAt = new Date().toISOString();
-                        (_a = analytics === null || analytics === void 0 ? void 0 : analytics.trackStepEngaged) === null || _a === void 0 ? void 0 : _a.call(analytics, {
-                            userId: currentUserIdRef.current,
-                            environment: analyticsRuntimeMode,
-                            stepId: engagedStepId,
-                            stepName: engagedStepName,
-                            stepType: engagedStepType,
-                            startedAt: engagedStartedAt,
-                            engagedAt,
-                            durationMs: FIRST_STEP_ENGAGEMENT_THRESHOLD_MS,
-                            engagementThresholdMs: FIRST_STEP_ENGAGEMENT_THRESHOLD_MS,
-                            featureFlags: postHogFeatureFlagsRef.current,
-                        });
-                    }, FIRST_STEP_ENGAGEMENT_THRESHOLD_MS);
-                }
             }
         }
         attributesAtStepStart.current = Object.assign({}, attributesRef.current);
@@ -464,12 +467,6 @@ export function useFunnelFlowController({ analytics, initialStepId, initialAttri
         renderedStepMeta === null || renderedStepMeta === void 0 ? void 0 : renderedStepMeta.type,
         safeActiveStepId,
     ]);
-    useEffect(() => () => {
-        if (firstStepEngagementTimerRef.current !== null) {
-            window.clearTimeout(firstStepEngagementTimerRef.current);
-            firstStepEngagementTimerRef.current = null;
-        }
-    }, []);
     useEffect(() => {
         setActiveStepId(safeInitialStepId);
     }, [safeInitialStepId]);
@@ -584,6 +581,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.50",
   "type": "module",
   "private": false,
   "main": "./dist/index.js",