wyreframe 0.1.0

package/src/parser/Interactions/InteractionMerger.mjs

@@ -0,0 +1,266 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Js_dict from "@rescript/runtime/lib/es6/Js_dict.js";
+import * as Js_json from "@rescript/runtime/lib/es6/Js_json.js";
+import * as Core__Array from "@rescript/core/src/Core__Array.mjs";
+import * as Belt_MapString from "@rescript/runtime/lib/es6/Belt_MapString.js";
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+function collectElementIds(element) {
+  switch (element.TAG) {
+    case "Box" :
+      return Core__Array.reduce(element.children, undefined, (acc, child) => Belt_SetString.union(acc, collectElementIds(child)));
+    case "Button" :
+    case "Input" :
+    case "Link" :
+      return Belt_SetString.add(undefined, element.id);
+    case "Row" :
+      return Core__Array.reduce(element.children, undefined, (acc, child) => Belt_SetString.union(acc, collectElementIds(child)));
+    case "Section" :
+      let withSection = Belt_SetString.add(undefined, element.name);
+      return Core__Array.reduce(element.children, withSection, (acc, child) => Belt_SetString.union(acc, collectElementIds(child)));
+    default:
+      return;
+  }
+}
+
+function collectSceneElementIds(scene) {
+  return Core__Array.reduce(scene.elements, undefined, (acc, element) => Belt_SetString.union(acc, collectElementIds(element)));
+}
+
+function buildSceneElementMap(ast) {
+  return Core__Array.reduce(ast.scenes, undefined, (acc, scene) => {
+    let elementIds = collectSceneElementIds(scene);
+    return Belt_MapString.set(acc, scene.id, elementIds);
+  });
+}
+
+function validateInteractions(sceneInteractionsList, sceneElementMap) {
+  let errors = [];
+  sceneInteractionsList.forEach(sceneInteractions => {
+    let sceneId = sceneInteractions.sceneId;
+    let elementIds = Belt_MapString.get(sceneElementMap, sceneId);
+    if (elementIds !== undefined) {
+      let elementIds$1 = Primitive_option.valFromOption(elementIds);
+      let seenElements = {
+        contents: undefined
+      };
+      sceneInteractions.interactions.forEach(interaction => {
+        let elementId = interaction.elementId;
+        if (Belt_SetString.has(seenElements.contents, elementId)) {
+          errors.push({
+            TAG: "DuplicateInteraction",
+            sceneId: sceneId,
+            elementId: elementId
+          });
+        } else {
+          seenElements.contents = Belt_SetString.add(seenElements.contents, elementId);
+        }
+        if (!Belt_SetString.has(elementIds$1, elementId)) {
+          errors.push({
+            TAG: "ElementNotFound",
+            sceneId: sceneId,
+            elementId: elementId,
+            position: undefined
+          });
+          return;
+        }
+      });
+      return;
+    }
+    errors.push({
+      TAG: "SceneNotFound",
+      sceneId: sceneId
+    });
+  });
+  return errors;
+}
+
+function findInteractionForElement(elementId, sceneInteractions) {
+  if (sceneInteractions !== undefined) {
+    return sceneInteractions.interactions.find(interaction => interaction.elementId === elementId);
+  }
+}
+
+function hasInputType(interaction) {
+  if (interaction === undefined) {
+    return false;
+  }
+  let json = Js_dict.get(interaction.properties, "type");
+  if (json === undefined) {
+    return false;
+  }
+  let str = Js_json.decodeString(json);
+  return str === "input";
+}
+
+function attachInteractionsToElement(element, sceneInteractions) {
+  switch (element.TAG) {
+    case "Box" :
+      let bounds = element.bounds;
+      let name = element.name;
+      let enhancedChildren = element.children.map(child => attachInteractionsToElement(child, sceneInteractions));
+      let isAnonymous = name === undefined;
+      let hasOnlyInputs = enhancedChildren.length > 0 && enhancedChildren.every(child => child.TAG === "Input");
+      let shouldUnwrap = isAnonymous && hasOnlyInputs && enhancedChildren.some(child => {
+        if (child.TAG === "Input") {
+          return hasInputType(findInteractionForElement(child.id, sceneInteractions));
+        } else {
+          return false;
+        }
+      });
+      if (!shouldUnwrap) {
+        return {
+          TAG: "Box",
+          name: name,
+          bounds: bounds,
+          children: enhancedChildren
+        };
+      }
+      let input = enhancedChildren[0];
+      if (input !== undefined) {
+        return input;
+      } else {
+        return {
+          TAG: "Box",
+          name: name,
+          bounds: bounds,
+          children: enhancedChildren
+        };
+      }
+    case "Button" :
+      let id = element.id;
+      let interaction = findInteractionForElement(id, sceneInteractions);
+      let actions = interaction !== undefined ? interaction.actions : [];
+      return {
+        TAG: "Button",
+        id: id,
+        text: element.text,
+        position: element.position,
+        align: element.align,
+        actions: actions
+      };
+    case "Input" :
+      let placeholder = element.placeholder;
+      let id$1 = element.id;
+      let interaction$1 = findInteractionForElement(id$1, sceneInteractions);
+      let enhancedPlaceholder;
+      if (interaction$1 !== undefined) {
+        let json = Js_dict.get(interaction$1.properties, "placeholder");
+        if (json !== undefined) {
+          let str = Js_json.decodeString(json);
+          enhancedPlaceholder = str !== undefined ? str : placeholder;
+        } else {
+          enhancedPlaceholder = placeholder;
+        }
+      } else {
+        enhancedPlaceholder = placeholder;
+      }
+      return {
+        TAG: "Input",
+        id: id$1,
+        placeholder: enhancedPlaceholder,
+        position: element.position
+      };
+    case "Link" :
+      let id$2 = element.id;
+      let interaction$2 = findInteractionForElement(id$2, sceneInteractions);
+      let actions$1 = interaction$2 !== undefined ? interaction$2.actions : [];
+      return {
+        TAG: "Link",
+        id: id$2,
+        text: element.text,
+        position: element.position,
+        align: element.align,
+        actions: actions$1
+      };
+    case "Row" :
+      let enhancedChildren$1 = element.children.map(child => attachInteractionsToElement(child, sceneInteractions));
+      return {
+        TAG: "Row",
+        children: enhancedChildren$1,
+        align: element.align
+      };
+    case "Section" :
+      let name$1 = element.name;
+      findInteractionForElement(name$1, sceneInteractions);
+      let enhancedChildren$2 = element.children.map(child => attachInteractionsToElement(child, sceneInteractions));
+      return {
+        TAG: "Section",
+        name: name$1,
+        children: enhancedChildren$2
+      };
+    default:
+      return element;
+  }
+}
+
+function attachInteractionsToScene(scene, sceneInteractionsList) {
+  let sceneInteractions = sceneInteractionsList.find(si => si.sceneId === scene.id);
+  let enhancedElements = scene.elements.map(element => attachInteractionsToElement(element, sceneInteractions));
+  return {
+    id: scene.id,
+    title: scene.title,
+    transition: scene.transition,
+    device: scene.device,
+    elements: enhancedElements
+  };
+}
+
+function mergeInteractions(ast, sceneInteractionsList) {
+  let sceneElementMap = buildSceneElementMap(ast);
+  let validationErrors = validateInteractions(sceneInteractionsList, sceneElementMap);
+  let hardErrors = validationErrors.filter(error => {
+    switch (error.TAG) {
+      case "ElementNotFound" :
+        return false;
+      case "DuplicateInteraction" :
+      case "SceneNotFound" :
+        return true;
+    }
+  });
+  if (hardErrors.length > 0) {
+    return {
+      TAG: "Error",
+      _0: hardErrors
+    };
+  }
+  let enhancedScenes = ast.scenes.map(scene => attachInteractionsToScene(scene, sceneInteractionsList));
+  return {
+    TAG: "Ok",
+    _0: {
+      scenes: enhancedScenes
+    }
+  };
+}
+
+function formatError(error) {
+  switch (error.TAG) {
+    case "ElementNotFound" :
+      return `Element "` + error.elementId + `" not found in scene "` + error.sceneId + `"`;
+    case "DuplicateInteraction" :
+      return `Duplicate interaction for element "` + error.elementId + `" in scene "` + error.sceneId + `"`;
+    case "SceneNotFound" :
+      return `Scene "` + error.sceneId + `" not found in wireframe`;
+  }
+}
+
+function formatErrors(errors) {
+  return errors.map(formatError).join("\n");
+}
+
+export {
+  collectElementIds,
+  collectSceneElementIds,
+  buildSceneElementMap,
+  validateInteractions,
+  findInteractionForElement,
+  hasInputType,
+  attachInteractionsToElement,
+  attachInteractionsToScene,
+  mergeInteractions,
+  formatError,
+  formatErrors,
+}
+/* No side effect */

package/src/parser/Interactions/InteractionMerger.res

@@ -0,0 +1,450 @@
+/**
+ * InteractionMerger.res
+ *
+ * Merges interaction definitions with wireframe AST elements.
+ * Validates that all element IDs referenced in interactions exist in the AST.
+ * Attaches properties and actions to the appropriate elements.
+ *
+ * Requirements: REQ-20 (Integration - Backward Compatibility)
+ */
+
+open Types
+
+// ============================================================================
+// Error Types
+// ============================================================================
+
+/**
+ * Errors that can occur during interaction merging
+ */
+type mergeError =
+  | ElementNotFound({
+      sceneId: string,
+      elementId: string,
+      position: option<string>, // Optional position info from interaction
+    })
+  | DuplicateInteraction({
+      sceneId: string,
+      elementId: string,
+    })
+  | SceneNotFound({sceneId: string})
+
+/**
+ * Result type for merge operation
+ */
+type mergeResult = result<ast, array<mergeError>>
+
+// ============================================================================
+// Element ID Collection
+// ============================================================================
+
+/**
+ * Recursively collect all element IDs from an element and its children.
+ * Returns a set of element IDs found in the element tree.
+ *
+ * @param element - The element to collect IDs from
+ * @returns Set of element IDs
+ */
+let rec collectElementIds = (element: element): Belt.Set.String.t => {
+  let ids = Belt.Set.String.empty
+
+  switch element {
+  | Box({children}) => {
+      // Recursively collect IDs from all children
+      children->Array.reduce(ids, (acc, child) => {
+        Belt.Set.String.union(acc, collectElementIds(child))
+      })
+    }
+  | Button({id}) => ids->Belt.Set.String.add(id)
+  | Input({id}) => ids->Belt.Set.String.add(id)
+  | Link({id}) => ids->Belt.Set.String.add(id)
+  | Checkbox(_) => ids // Checkboxes don't have explicit IDs
+  | Text(_) => ids // Text elements don't have explicit IDs
+  | Divider(_) => ids // Dividers don't have IDs
+  | Row({children}) => {
+      children->Array.reduce(ids, (acc, child) => {
+        Belt.Set.String.union(acc, collectElementIds(child))
+      })
+    }
+  | Section({children, name}) => {
+      // Add section name as ID
+      let withSection = ids->Belt.Set.String.add(name)
+      children->Array.reduce(withSection, (acc, child) => {
+        Belt.Set.String.union(acc, collectElementIds(child))
+      })
+    }
+  }
+}
+
+/**
+ * Collect all element IDs from a scene's elements.
+ *
+ * @param scene - The scene to collect IDs from
+ * @returns Set of element IDs in the scene
+ */
+let collectSceneElementIds = (scene: scene): Belt.Set.String.t => {
+  scene.elements->Array.reduce(Belt.Set.String.empty, (acc, element) => {
+    Belt.Set.String.union(acc, collectElementIds(element))
+  })
+}
+
+/**
+ * Build a map of scene IDs to their element ID sets.
+ *
+ * @param ast - The AST to analyze
+ * @returns Map of sceneId -> Set of element IDs
+ */
+let buildSceneElementMap = (ast: ast): Belt.Map.String.t<Belt.Set.String.t> => {
+  ast.scenes->Array.reduce(Belt.Map.String.empty, (acc, scene) => {
+    let elementIds = collectSceneElementIds(scene)
+    acc->Belt.Map.String.set(scene.id, elementIds)
+  })
+}
+
+// ============================================================================
+// Interaction Validation
+// ============================================================================
+
+/**
+ * Validate that all element IDs in interactions exist in the AST.
+ *
+ * @param sceneInteractions - Interactions to validate
+ * @param sceneElementMap - Map of scene IDs to element IDs
+ * @returns Array of validation errors (empty if all valid)
+ */
+let validateInteractions = (
+  sceneInteractionsList: array<sceneInteractions>,
+  sceneElementMap: Belt.Map.String.t<Belt.Set.String.t>,
+): array<mergeError> => {
+  let errors = []
+
+  sceneInteractionsList->Array.forEach(sceneInteractions => {
+    let sceneId = sceneInteractions.sceneId
+
+    // Check if scene exists
+    switch sceneElementMap->Belt.Map.String.get(sceneId) {
+    | None => {
+        errors->Array.push(SceneNotFound({sceneId: sceneId}))->ignore
+      }
+    | Some(elementIds) => {
+        // Track seen element IDs to detect duplicates
+        let seenElements = ref(Belt.Set.String.empty)
+
+        // Validate each interaction
+        sceneInteractions.interactions->Array.forEach(interaction => {
+          let elementId = interaction.elementId
+
+          // Check for duplicate interaction
+          if seenElements.contents->Belt.Set.String.has(elementId) {
+            errors
+            ->Array.push(
+              DuplicateInteraction({
+                sceneId: sceneId,
+                elementId: elementId,
+              }),
+            )
+            ->ignore
+          } else {
+            seenElements := seenElements.contents->Belt.Set.String.add(elementId)
+          }
+
+          // Check if element exists in scene
+          if !(elementIds->Belt.Set.String.has(elementId)) {
+            errors
+            ->Array.push(
+              ElementNotFound({
+                sceneId: sceneId,
+                elementId: elementId,
+                position: None,
+              }),
+            )
+            ->ignore
+          }
+        })
+      }
+    }
+  })
+
+  errors
+}
+
+// ============================================================================
+// Element Enhancement
+// ============================================================================
+
+/**
+ * Enhanced element type that includes interaction data.
+ * This is used internally during merging but converted back to
+ * the standard element type for the final AST.
+ */
+type elementWithInteraction = {
+  element: element,
+  interaction: option<interaction>,
+}
+
+/**
+ * Find interaction for a given element ID in a scene's interactions.
+ *
+ * @param elementId - The element ID to find interaction for
+ * @param sceneInteractions - Scene interactions to search
+ * @returns Option containing the interaction if found
+ */
+let findInteractionForElement = (
+  elementId: string,
+  sceneInteractions: option<sceneInteractions>,
+): option<interaction> => {
+  switch sceneInteractions {
+  | None => None
+  | Some(si) => {
+      si.interactions->Array.find(interaction => interaction.elementId === elementId)
+    }
+  }
+}
+
+/**
+ * Helper to check if an interaction has type: "input" property.
+ */
+let hasInputType = (interaction: option<interaction>): bool => {
+  switch interaction {
+  | Some({properties}) => {
+      switch properties->Js.Dict.get("type") {
+      | Some(json) => {
+          switch Js.Json.decodeString(json) {
+          | Some(str) => str === "input"
+          | None => false
+          }
+        }
+      | None => false
+      }
+    }
+  | None => false
+  }
+}
+
+/**
+ * Recursively attach interactions to elements.
+ * This creates a new element tree with interaction data attached.
+ *
+ * Key feature: If an element has type: "input" in its interaction properties,
+ * parent Box elements containing only that Input will be unwrapped to render
+ * as the Input directly.
+ *
+ * @param element - The element to process
+ * @param sceneInteractions - Interactions for the current scene
+ * @returns The processed element (may be unwrapped if type: input specified)
+ */
+let rec attachInteractionsToElement = (
+  element: element,
+  sceneInteractions: option<sceneInteractions>,
+): element => {
+  switch element {
+  | Box({name, bounds, children}) => {
+      // Recursively process children first
+      let enhancedChildren = children->Array.map(child => {
+        attachInteractionsToElement(child, sceneInteractions)
+      })
+
+      // Check if this is an input-only box that should be unwrapped
+      // A box is unwrapped if:
+      // 1. It has no name (anonymous box)
+      // 2. It contains only Input elements
+      // 3. At least one Input has type: "input" in its interaction
+      let isAnonymous = name === None
+      let hasOnlyInputs =
+        enhancedChildren->Array.length > 0 &&
+        enhancedChildren->Array.every(child => {
+          switch child {
+          | Input(_) => true
+          | _ => false
+          }
+        })
+
+      let shouldUnwrap = isAnonymous && hasOnlyInputs && {
+        enhancedChildren->Array.some(child => {
+          switch child {
+          | Input({id, _}) => {
+              let interaction = findInteractionForElement(id, sceneInteractions)
+              hasInputType(interaction)
+            }
+          | _ => false
+          }
+        })
+      }
+
+      if shouldUnwrap {
+        // Return the first Input directly (unwrap the box)
+        switch enhancedChildren->Array.get(0) {
+        | Some(input) => input
+        | None => Box({name, bounds, children: enhancedChildren})
+        }
+      } else {
+        Box({name, bounds, children: enhancedChildren})
+      }
+    }
+  | Button({id, text, position, align}) => {
+      // Find interaction for this button (if any)
+      let interaction = findInteractionForElement(id, sceneInteractions)
+      // Extract actions from interaction
+      let actions = switch interaction {
+      | Some({actions}) => actions
+      | None => []
+      }
+      Button({id, text, position, align, actions})
+    }
+  | Input({id, placeholder, position}) => {
+      let interaction = findInteractionForElement(id, sceneInteractions)
+      // Extract placeholder from interaction properties if available
+      let enhancedPlaceholder = switch interaction {
+      | Some({properties}) => {
+          switch properties->Js.Dict.get("placeholder") {
+          | Some(json) => {
+              switch Js.Json.decodeString(json) {
+              | Some(str) => Some(str)
+              | None => placeholder
+              }
+            }
+          | None => placeholder
+          }
+        }
+      | None => placeholder
+      }
+      Input({id, placeholder: enhancedPlaceholder, position})
+    }
+  | Link({id, text, position, align}) => {
+      // Find interaction for this link (if any)
+      let interaction = findInteractionForElement(id, sceneInteractions)
+      // Extract actions from interaction
+      let actions = switch interaction {
+      | Some({actions}) => actions
+      | None => []
+      }
+      Link({id, text, position, align, actions})
+    }
+  | Row({children, align}) => {
+      let enhancedChildren = children->Array.map(child => {
+        attachInteractionsToElement(child, sceneInteractions)
+      })
+      Row({children: enhancedChildren, align})
+    }
+  | Section({name, children}) => {
+      let _interaction = findInteractionForElement(name, sceneInteractions)
+      let enhancedChildren = children->Array.map(child => {
+        attachInteractionsToElement(child, sceneInteractions)
+      })
+      Section({name, children: enhancedChildren})
+    }
+  // Elements without IDs just pass through
+  | Checkbox(_) as el => el
+  | Text(_) as el => el
+  | Divider(_) as el => el
+  }
+}
+
+/**
+ * Attach interactions to all elements in a scene.
+ *
+ * @param scene - The scene to process
+ * @param sceneInteractionsList - All scene interactions
+ * @returns Enhanced scene with interactions attached
+ */
+let attachInteractionsToScene = (
+  scene: scene,
+  sceneInteractionsList: array<sceneInteractions>,
+): scene => {
+  // Find interactions for this scene
+  let sceneInteractions = sceneInteractionsList->Array.find(si => si.sceneId === scene.id)
+
+  // Process all elements
+  let enhancedElements = scene.elements->Array.map(element => {
+    attachInteractionsToElement(element, sceneInteractions)
+  })
+
+  {
+    id: scene.id,
+    title: scene.title,
+    transition: scene.transition,
+    device: scene.device,
+    elements: enhancedElements,
+  }
+}
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+/**
+ * Merge interactions into the AST.
+ * Validates that all element IDs exist and attaches interaction data to elements.
+ *
+ * Lenient mode: ElementNotFound errors are treated as warnings and skipped.
+ * Only SceneNotFound and DuplicateInteraction are hard errors.
+ *
+ * @param ast - The wireframe AST
+ * @param sceneInteractionsList - Array of scene interactions to merge
+ * @returns Result containing merged AST or validation errors
+ *
+ * @example
+ * let result = mergeInteractions(wireframeAst, interactions)
+ * switch result {
+ * | Ok(mergedAst) => Js.log("Merge successful!")
+ * | Error(errors) => errors->Array.forEach(err => Js.log(err))
+ * }
+ */
+let mergeInteractions = (
+  ast: ast,
+  sceneInteractionsList: array<sceneInteractions>,
+): mergeResult => {
+  // Build map of scene IDs to element IDs
+  let sceneElementMap = buildSceneElementMap(ast)
+
+  // Validate all interactions
+  let validationErrors = validateInteractions(sceneInteractionsList, sceneElementMap)
+
+  // Separate hard errors from soft errors (ElementNotFound)
+  let hardErrors = validationErrors->Array.filter(error => {
+    switch error {
+    | ElementNotFound(_) => false // Soft error - element might not exist yet
+    | SceneNotFound(_) => true // Hard error - scene must exist
+    | DuplicateInteraction(_) => true // Hard error - duplicates are problematic
+    }
+  })
+
+  if hardErrors->Array.length > 0 {
+    // Return only hard errors
+    Error(hardErrors)
+  } else {
+    // Attach interactions to scenes (missing elements are silently skipped)
+    let enhancedScenes = ast.scenes->Array.map(scene => {
+      attachInteractionsToScene(scene, sceneInteractionsList)
+    })
+
+    // Return enhanced AST
+    Ok({scenes: enhancedScenes})
+  }
+}
+
+/**
+ * Format merge error for display.
+ *
+ * @param error - The merge error to format
+ * @returns Human-readable error message
+ */
+let formatError = (error: mergeError): string => {
+  switch error {
+  | ElementNotFound({sceneId, elementId}) =>
+    `Element "${elementId}" not found in scene "${sceneId}"`
+  | DuplicateInteraction({sceneId, elementId}) =>
+    `Duplicate interaction for element "${elementId}" in scene "${sceneId}"`
+  | SceneNotFound({sceneId}) => `Scene "${sceneId}" not found in wireframe`
+  }
+}
+
+/**
+ * Format all merge errors for display.
+ *
+ * @param errors - Array of merge errors
+ * @returns Formatted error messages joined with newlines
+ */
+let formatErrors = (errors: array<mergeError>): string => {
+  errors->Array.map(formatError)->Array.join("\n")
+}