@sonata-innovations/fiber-types 1.0.5 → 1.0.6

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export type { ValidationRuleType, ValidationRule, FlowValidationConfig, } from "
 export { normalizeOptions } from "./normalize-options";
 export type { FlowData, ScreenData, ComponentData, CalculationData, FileUploadData, FileUploadBase64Data, FileUploadS3Data, RangeValue, } from "./flow-data";
 export { regenerateComponentUUIDs, regenerateFlowUUIDs, } from "./uuid-regeneration";
+export { normalizeConditionalOrder } from "./normalize-conditional-order";
 export type { PresetData, TemplateData } from "./preset-template-data";
 export type { CalculationFormat, FlowCalculation, } from "./calculation";
 export type { ComponentWidth, DateFormat, ComponentInputType, ComponentDisplayProperties, ComponentDividerProperties, ComponentInputProperties, OptionItem, ComponentOptionProperties, ComponentSliderProperties, ComponentSwitchProperties, ComponentRatingProperties, ComponentFileUploadProperties, ComponentGroupProperties, ComponentRepeaterProperties, ComponentDateProperties, ComponentTimeProperties, ComponentDateTimeProperties, ComponentDateRangeProperties, ComponentTimeRangeProperties, ComponentDateTimeRangeProperties, ComponentYesNoProperties, ComponentConfirmProperties, ComponentColorPickerProperties, CardSelectOption, ComponentCardSelectProperties, ComponentCalloutVariant, ComponentCalloutProperties, TableColumn, TableRow, ComponentTableProperties, SignatureMode, ComponentSignatureProperties, ComponentComputedProperties, } from "./properties";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,IAAI,EACJ,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,SAAS,EACT,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,cAAc,EACd,YAAY,EACZ,YAAY,GACb,MAAM,QAAQ,CAAC;AAEhB,YAAY,EACV,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,mBAAmB,EACnB,cAAc,EACd,mBAAmB,GACpB,MAAM,cAAc,CAAC;AAEtB,YAAY,EACV,kBAAkB,EAClB,cAAc,EACd,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,YAAY,EACV,QAAQ,EACR,UAAU,EACV,aAAa,EACb,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,UAAU,GACX,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAE7B,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEvE,YAAY,EACV,iBAAiB,EACjB,eAAe,GAChB,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,cAAc,EACd,UAAU,EACV,kBAAkB,EAClB,0BAA0B,EAC1B,0BAA0B,EAC1B,wBAAwB,EACxB,UAAU,EACV,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,6BAA6B,EAC7B,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,EACvB,2BAA2B,EAC3B,4BAA4B,EAC5B,4BAA4B,EAC5B,gCAAgC,EAChC,wBAAwB,EACxB,0BAA0B,EAC1B,8BAA8B,EAC9B,gBAAgB,EAChB,6BAA6B,EAC7B,uBAAuB,EACvB,0BAA0B,EAC1B,WAAW,EACX,QAAQ,EACR,wBAAwB,EACxB,aAAa,EACb,4BAA4B,EAC5B,2BAA2B,GAC5B,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,IAAI,EACJ,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,SAAS,EACT,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,cAAc,EACd,YAAY,EACZ,YAAY,GACb,MAAM,QAAQ,CAAC;AAEhB,YAAY,EACV,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,mBAAmB,EACnB,cAAc,EACd,mBAAmB,GACpB,MAAM,cAAc,CAAC;AAEtB,YAAY,EACV,kBAAkB,EAClB,cAAc,EACd,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,YAAY,EACV,QAAQ,EACR,UAAU,EACV,aAAa,EACb,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,UAAU,GACX,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAE1E,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEvE,YAAY,EACV,iBAAiB,EACjB,eAAe,GAChB,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,cAAc,EACd,UAAU,EACV,kBAAkB,EAClB,0BAA0B,EAC1B,0BAA0B,EAC1B,wBAAwB,EACxB,UAAU,EACV,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,6BAA6B,EAC7B,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,EACvB,2BAA2B,EAC3B,4BAA4B,EAC5B,4BAA4B,EAC5B,gCAAgC,EAChC,wBAAwB,EACxB,0BAA0B,EAC1B,8BAA8B,EAC9B,gBAAgB,EAChB,6BAA6B,EAC7B,uBAAuB,EACvB,0BAA0B,EAC1B,WAAW,EACX,QAAQ,EACR,wBAAwB,EACxB,aAAa,EACb,4BAA4B,EAC5B,2BAA2B,GAC5B,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -1,2 +1,3 @@
 export { normalizeOptions } from "./normalize-options";
 export { regenerateComponentUUIDs, regenerateFlowUUIDs, } from "./uuid-regeneration";
+export { normalizeConditionalOrder } from "./normalize-conditional-order";

package/dist/normalize-conditional-order.d.ts

@@ -0,0 +1,8 @@
+import type { Flow } from "./flow";
+/**
+ * Returns a new Flow in which every top-level conditional component is moved
+ * to immediately follow the component it depends on. Pure: the input Flow is
+ * not mutated and component objects are reused by reference.
+ */
+export declare function normalizeConditionalOrder(flow: Flow): Flow;
+//# sourceMappingURL=normalize-conditional-order.d.ts.map

package/dist/normalize-conditional-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-conditional-order.d.ts","sourceRoot":"","sources":["../src/normalize-conditional-order.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,IAAI,EAAyB,MAAM,QAAQ,CAAC;AAgB1D;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAqL1D"}

package/dist/normalize-conditional-order.js

@@ -0,0 +1,230 @@
+/* ==========================================================================
+   Conditional-order normalization — relocate each conditional component so it
+   sits immediately after the component it depends on.
+
+   Why: FBTL groups a conditional with its trigger ONLY when the conditional
+   immediately follows that trigger in document order. Generators (e.g. an AI
+   authoring step) often emit a conditional after an unrelated non-conditional
+   sibling, so FBTL can't group them and the conditional becomes a detached
+   downstream screen. Run a Flow through this BEFORE loading it into FBTL and
+   the adjacency FBTL expects is guaranteed.
+
+   Scope and guarantees:
+   - Operates on TOP-LEVEL screen components only. Nested children (inside
+     groups/repeaters) already share their parent's screen and are untouched.
+   - Only REORDERS. No condition, property, uuid, label, or screen-level
+     condition is ever rewritten. Component object references are preserved.
+   - A condition source pointing at a question nested inside a group/repeater
+     resolves to that nested question's top-level ancestor card, so the
+     conditional anchors on the card that actually carries the trigger.
+   - A conditional with multiple component sources is anchored after the
+     LATEST of its (resolved) sources, so every dependency precedes it.
+   - Dependency chains (A → C → D) are resolved trigger-before-dependent.
+   - Cycles and dangling sources are left in place (never relocated, never
+     loops).
+   - Every empty screen is dropped — both those emptied by relocation and any
+     the generator emitted empty. Original screen order, uuids, labels, and
+     screen-level conditions of surviving screens are preserved.
+   - First-screen identity is preserved: if relocation drops the original
+     first screen, its uuid is transplanted onto the new first screen so
+     FBTL's stable round-trip screenUUID does not shift.
+   ========================================================================== */
+/** All component-type source UUIDs referenced by a condition config.
+ *  `sourceType` undefined is treated as "component" (matches FBTL). */
+function conditionSourceUUIDs(config) {
+    const rules = config?.when?.rules;
+    if (!rules || rules.length === 0)
+        return [];
+    const out = [];
+    for (const rule of rules) {
+        if (rule.sourceType && rule.sourceType !== "component")
+            continue;
+        if (rule.source)
+            out.push(rule.source);
+    }
+    return out;
+}
+/**
+ * Returns a new Flow in which every top-level conditional component is moved
+ * to immediately follow the component it depends on. Pure: the input Flow is
+ * not mutated and component objects are reused by reference.
+ */
+export function normalizeConditionalOrder(flow) {
+    const screens = flow.screens ?? [];
+    const flat = [];
+    screens.forEach((screen, screenIndex) => {
+        for (const comp of screen.components ?? []) {
+            flat.push({ comp, screenIndex });
+        }
+    });
+    const byUUID = new Map();
+    for (const e of flat)
+        byUUID.set(e.comp.uuid, e);
+    const originalIndex = new Map();
+    flat.forEach((e, i) => originalIndex.set(e.comp.uuid, i));
+    // Map every component UUID — including ones nested inside group/repeater
+    // children — to its TOP-LEVEL ancestor. Lets a condition that points at a
+    // nested question anchor on the top-level card that contains it instead of
+    // being treated as dangling.
+    const topAncestor = new Map();
+    function indexSubtree(comp, rootUUID) {
+        topAncestor.set(comp.uuid, rootUUID);
+        for (const child of comp.components ?? []) {
+            indexSubtree(child, rootUUID);
+        }
+    }
+    for (const e of flat)
+        indexSubtree(e.comp, e.comp.uuid);
+    // Resolve each component's anchor: the source it should follow. Each source
+    // UUID is mapped to its top-level ancestor; the anchor is the resolved
+    // ancestor that appears LAST in original document order, so every dependency
+    // of a multi-source condition ends up before it. Returns null when there is
+    // no condition, no component source, or the source resolves to nothing /
+    // back to this component itself.
+    function anchorUUID(comp) {
+        const resolved = conditionSourceUUIDs(comp.conditions)
+            .map((uuid) => topAncestor.get(uuid))
+            .filter((uuid) => uuid !== undefined && uuid !== comp.uuid && byUUID.has(uuid));
+        if (resolved.length === 0)
+            return null;
+        let best = null;
+        let bestIdx = -1;
+        for (const uuid of resolved) {
+            const idx = originalIndex.get(uuid) ?? -1;
+            if (idx > bestIdx) {
+                bestIdx = idx;
+                best = uuid;
+            }
+        }
+        return best;
+    }
+    // Dependency depth, with cycle detection. Cyclic components report depth 0
+    // so they are treated as un-anchored (left in place, never looped on).
+    const depthCache = new Map();
+    function depthOf(uuid, seen) {
+        const cached = depthCache.get(uuid);
+        if (cached !== undefined)
+            return cached;
+        if (seen.has(uuid))
+            return 0; // cycle — break
+        const entry = byUUID.get(uuid);
+        if (!entry)
+            return 0;
+        const anchor = anchorUUID(entry.comp);
+        if (!anchor) {
+            depthCache.set(uuid, 0);
+            return 0;
+        }
+        seen.add(uuid);
+        const d = depthOf(anchor, seen) + 1;
+        seen.delete(uuid);
+        depthCache.set(uuid, d);
+        return d;
+    }
+    function isCyclic(uuid) {
+        // Walk anchors; if we revisit a node before hitting a root, it's a cycle.
+        const path = new Set();
+        let cur = uuid;
+        while (cur) {
+            if (path.has(cur))
+                return true;
+            path.add(cur);
+            const entry = byUUID.get(cur);
+            if (!entry)
+                return false;
+            cur = anchorUUID(entry.comp);
+        }
+        return false;
+    }
+    // Working order starts as original document order; relocations splice in.
+    const order = flat.map((e) => e.comp);
+    // Process relocatable conditionals trigger-before-dependent (depth asc),
+    // tie-broken by original index for stable sibling ordering.
+    const movable = flat
+        .map((e) => e.comp)
+        .filter((c) => anchorUUID(c) !== null && !isCyclic(c.uuid))
+        .sort((a, b) => {
+        const da = depthOf(a.uuid, new Set());
+        const db = depthOf(b.uuid, new Set());
+        if (da !== db)
+            return da - db;
+        return (originalIndex.get(a.uuid) ?? 0) - (originalIndex.get(b.uuid) ?? 0);
+    });
+    for (const comp of movable) {
+        const anchor = anchorUUID(comp);
+        if (!anchor)
+            continue;
+        const from = order.indexOf(comp);
+        if (from === -1)
+            continue;
+        order.splice(from, 1);
+        let at = order.findIndex((c) => c.uuid === anchor);
+        if (at === -1) {
+            // Anchor vanished (shouldn't happen) — restore original slot.
+            order.splice(Math.min(from, order.length), 0, comp);
+            continue;
+        }
+        // Skip past any conditionals already attached to this anchor so multiple
+        // dependents of one trigger keep their original relative order.
+        let insertAt = at + 1;
+        while (insertAt < order.length && anchorUUID(order[insertAt]) === anchor) {
+            insertAt++;
+        }
+        order.splice(insertAt, 0, comp);
+    }
+    // Resolve the screen a component lands on: follow anchors to the root
+    // (non-conditional / cyclic) component and use that screen.
+    const screenCache = new Map();
+    function targetScreen(uuid, seen) {
+        const cached = screenCache.get(uuid);
+        if (cached !== undefined)
+            return cached;
+        const entry = byUUID.get(uuid);
+        if (!entry)
+            return 0;
+        if (seen.has(uuid))
+            return entry.screenIndex; // cycle — own screen
+        if (isCyclic(uuid))
+            return entry.screenIndex;
+        const anchor = anchorUUID(entry.comp);
+        if (!anchor) {
+            screenCache.set(uuid, entry.screenIndex);
+            return entry.screenIndex;
+        }
+        seen.add(uuid);
+        const s = targetScreen(anchor, seen);
+        seen.delete(uuid);
+        screenCache.set(uuid, s);
+        return s;
+    }
+    // Re-emit screens in original order; components in final relocated order
+    // filtered to their target screen. Drop every empty screen — both those
+    // emptied by relocation and any that arrived empty from the generator.
+    const buckets = screens.map(() => []);
+    for (const comp of order) {
+        buckets[targetScreen(comp.uuid, new Set())].push(comp);
+    }
+    const newScreens = [];
+    screens.forEach((screen, i) => {
+        const comps = buckets[i];
+        if (comps.length === 0)
+            return; // empty — drop
+        newScreens.push({ ...screen, components: comps });
+    });
+    // Preserve first-screen identity: FBTL pins screens[0]'s uuid as its stable
+    // round-trip screenUUID. If relocation dropped the original first screen,
+    // transplant its uuid onto the new first screen so that anchor doesn't
+    // shift. The surviving screen keeps its own label — it carries meaning the
+    // dropped screen's would not.
+    const originalFirst = screens[0];
+    if (originalFirst && newScreens.length > 0) {
+        if (newScreens[0].uuid !== originalFirst.uuid) {
+            newScreens[0] = { ...newScreens[0], uuid: originalFirst.uuid };
+        }
+    }
+    else if (originalFirst && newScreens.length === 0) {
+        // Whole flow had no components — keep one well-formed empty screen.
+        newScreens.push({ ...originalFirst, components: [] });
+    }
+    return { ...flow, screens: newScreens };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sonata-innovations/fiber-types",
-	"version": "1.0.5",
+	"version": "1.0.6",
 	"description": "TypeScript type definitions for the Fiber form builder system",
 	"keywords": ["fiber", "form-builder", "types", "typescript", "flow-json"],
 	"license": "MIT",