wyreframe 0.1.0

package/src/parser/Parser.gen.tsx

@@ -0,0 +1,96 @@
+/* TypeScript file generated from Parser.res by genType. */
+
+/* eslint-disable */
+/* tslint:disable */
+
+import * as ParserJS from './Parser.mjs';
+
+import type {ast as Types_ast} from '../../src/parser/Core/Types.gen';
+
+import type {sceneInteractions as Types_sceneInteractions} from '../../src/parser/Core/Types.gen';
+
+import type {t as ErrorTypes_t} from '../../src/parser/Errors/ErrorTypes.gen';
+
+/** * Parse result type - either a successful AST or an array of parse errors.
+ * This Result type is compatible with TypeScript through GenType. */
+export type parseResult = 
+    { TAG: "Ok"; _0: Types_ast }
+  | { TAG: "Error"; _0: ErrorTypes_t[] };
+
+/** * Interaction parse result type. */
+export type interactionResult = 
+    { TAG: "Ok"; _0: Types_sceneInteractions[] }
+  | { TAG: "Error"; _0: ErrorTypes_t[] };
+
+/** * Main parsing function - parses mixed text containing wireframe and interactions.
+ *
+ * This function accepts a single text input that can contain:
+ * - ASCII wireframe (boxes with +---+, | |, etc.)
+ * - Interaction DSL (#id:, [Button]:, "Link": with properties)
+ * - Markdown, comments, or other noise (automatically ignored)
+ *
+ * The parser intelligently extracts wireframe and interaction content,
+ * allowing you to write everything in one place.
+ *
+ * Example:
+ * ```
+ * @scene: login
+ *
+ * +---------------------------+
+ * |       'WYREFRAME'         |
+ * |  +---------------------+  |
+ * |  | #email              |  |
+ * |  +---------------------+  |
+ * |       [ Login ]           |
+ * +---------------------------+
+ *
+ * #email:
+ *   placeholder: "Enter your email"
+ *
+ * [Login]:
+ *   @click -> goto(dashboard)
+ * ```
+ *
+ * @param text Mixed text containing wireframe and/or interactions
+ * @returns Result containing AST or array of parse errors
+ *
+ * REQ-20: Backward Compatibility
+ * REQ-21: Public API Stability
+ * REQ-28: Error Recovery (collect all errors) */
+export const parse: (text:string) => parseResult = ParserJS.parse as any;
+
+/** * Parse only the wireframe structure (no interactions).
+ * Convenience function that calls parseInternal(wireframe, None).
+ *
+ * @param wireframe ASCII wireframe string
+ * @returns Result containing AST or array of parse errors
+ *
+ * REQ-21: Public API Stability */
+export const parseWireframe: (wireframe:string) => parseResult = ParserJS.parseWireframe as any;
+
+/** * Parse only the interaction DSL.
+ * Useful when interactions are defined separately from the wireframe structure.
+ *
+ * @param dsl Interaction DSL string
+ * @returns Result containing scene interactions or array of parse errors
+ *
+ * REQ-21: Public API Stability */
+export const parseInteractions: (dsl:string) => interactionResult = ParserJS.parseInteractions as any;
+
+/** * Merge interaction definitions into an existing AST.
+ * Attaches properties and actions to elements based on element IDs.
+ *
+ * @param ast Base AST from wireframe parsing
+ * @param sceneInteractions Array of scene interactions to merge
+ * @returns AST with interactions merged into elements
+ *
+ * Integration requirement */
+export const mergeInteractions: (ast:Types_ast, _sceneInteractions:Types_sceneInteractions[]) => Types_ast = ParserJS.mergeInteractions as any;
+
+/** * Parser version string.
+ * Exported to TypeScript for version checking and compatibility validation. */
+export const version: string = ParserJS.version as any;
+
+/** * Parser implementation identifier.
+ * Useful for distinguishing between legacy JavaScript and new ReScript parser. */
+export const implementation: string = ParserJS.implementation as any;

package/src/parser/Parser.mjs

@@ -0,0 +1,212 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Grid from "./Core/Grid.mjs";
+import * as ErrorTypes from "./Errors/ErrorTypes.mjs";
+import * as Core__Array from "@rescript/core/src/Core__Array.mjs";
+import * as ShapeDetector from "./Detector/ShapeDetector.mjs";
+import * as TextExtractor from "./TextExtractor.mjs";
+import * as ParserRegistry from "./Semantic/ParserRegistry.mjs";
+import * as SemanticParser from "./Semantic/SemanticParser.mjs";
+import * as InteractionMerger from "./Interactions/InteractionMerger.mjs";
+import * as InteractionParser from "./Interactions/InteractionParser.mjs";
+
+function scanGrid(wireframe) {
+  let normalized = wireframe.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+  let lines = normalized.split("\n");
+  let grid = Grid.fromLines(lines);
+  return {
+    TAG: "Ok",
+    _0: grid
+  };
+}
+
+let detectShapes = ShapeDetector.detect;
+
+function convertBox(tracerBox) {
+  return {
+    name: tracerBox.name,
+    bounds: tracerBox.bounds,
+    children: tracerBox.children.map(convertBox)
+  };
+}
+
+function parseSemantics(grid, shapes) {
+  let registry = ParserRegistry.makeDefault();
+  let semanticBoxes = shapes.map(convertBox);
+  return SemanticParser.parse({
+    gridCells: grid.cells,
+    shapes: semanticBoxes,
+    registry: registry
+  });
+}
+
+function parseInteractionsDSL(dsl) {
+  let interactions = InteractionParser.parse(dsl);
+  if (interactions.TAG === "Ok") {
+    return {
+      TAG: "Ok",
+      _0: interactions._0
+    };
+  }
+  let match = interactions._0;
+  let error = ErrorTypes.make({
+    TAG: "InvalidInteractionDSL",
+    message: match.message,
+    position: match.position
+  }, undefined);
+  return {
+    TAG: "Error",
+    _0: [error]
+  };
+}
+
+function mergeInteractionsIntoAST(ast, sceneInteractions) {
+  let mergedAst = InteractionMerger.mergeInteractions(ast, sceneInteractions);
+  if (mergedAst.TAG === "Ok") {
+    return mergedAst._0;
+  } else {
+    return ast;
+  }
+}
+
+function parseSingleScene(sceneContent, sceneMetadata, errors) {
+  let gridResult = scanGrid(sceneContent);
+  if (gridResult.TAG === "Ok") {
+    let grid = gridResult._0;
+    let shapesResult = ShapeDetector.detect(grid);
+    let shapes;
+    if (shapesResult.TAG === "Ok") {
+      shapes = shapesResult._0;
+    } else {
+      shapesResult._0.forEach(err => {
+        errors.push(err);
+      });
+      shapes = [];
+    }
+    let registry = ParserRegistry.makeDefault();
+    let semanticBoxes = shapes.map(convertBox);
+    let elements = semanticBoxes.flatMap(box => {
+      let boxElement = SemanticParser.parseBoxRecursive(box, grid.cells, registry);
+      if (boxElement.TAG === "Box") {
+        if (boxElement.name !== undefined) {
+          return [boxElement];
+        } else {
+          return boxElement.children;
+        }
+      } else {
+        return [boxElement];
+      }
+    });
+    return {
+      id: sceneMetadata.id,
+      title: sceneMetadata.title,
+      transition: sceneMetadata.transition,
+      device: sceneMetadata.device,
+      elements: elements
+    };
+  }
+  gridResult._0.forEach(err => {
+    errors.push(err);
+  });
+}
+
+function parseInternal(wireframe, interactions) {
+  let allErrors = [];
+  let sceneBlocks = SemanticParser.splitSceneBlocks(wireframe);
+  let trimmed = wireframe.trim();
+  if (sceneBlocks.length === 0 && trimmed === "") {
+    return {
+      TAG: "Ok",
+      _0: {
+        scenes: []
+      }
+    };
+  }
+  let scenes = [];
+  sceneBlocks.forEach(block => {
+    let lines = block.split("\n");
+    let match = SemanticParser.parseSceneDirectives(lines);
+    let sceneContent = match[1].join("\n");
+    let scene = parseSingleScene(sceneContent, match[0], allErrors);
+    if (scene !== undefined) {
+      scenes.push(scene);
+      return;
+    }
+  });
+  let baseAst = {
+    scenes: scenes
+  };
+  let finalAst;
+  if (interactions !== undefined) {
+    let interactionsResult = parseInteractionsDSL(interactions);
+    if (interactionsResult.TAG === "Ok") {
+      finalAst = mergeInteractionsIntoAST(baseAst, interactionsResult._0);
+    } else {
+      interactionsResult._0.forEach(err => {
+        allErrors.push(err);
+      });
+      finalAst = baseAst;
+    }
+  } else {
+    finalAst = baseAst;
+  }
+  let totalElements = Core__Array.reduce(finalAst.scenes, 0, (acc, scene) => acc + scene.elements.length | 0);
+  if (allErrors.length > 0 && totalElements === 0) {
+    return {
+      TAG: "Error",
+      _0: allErrors
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: finalAst
+    };
+  }
+}
+
+function parse(text) {
+  let extracted = TextExtractor.extract(text);
+  let interactions = extracted.interactions.trim() === "" ? undefined : extracted.interactions;
+  return parseInternal(extracted.wireframe, interactions);
+}
+
+function parseWireframe(wireframe) {
+  return parseInternal(wireframe, undefined);
+}
+
+let parseInteractions = parseInteractionsDSL;
+
+function mergeInteractions(ast, _sceneInteractions) {
+  return ast;
+}
+
+function collectErrors(gridErrors, shapeErrors, semanticErrors) {
+  return [
+    gridErrors,
+    shapeErrors,
+    semanticErrors
+  ].flatMap(x => x);
+}
+
+let version = "0.1.0";
+
+let implementation = "rescript";
+
+export {
+  scanGrid,
+  detectShapes,
+  convertBox,
+  parseSemantics,
+  parseInteractionsDSL,
+  mergeInteractionsIntoAST,
+  parseSingleScene,
+  parseInternal,
+  parse,
+  parseWireframe,
+  parseInteractions,
+  mergeInteractions,
+  collectErrors,
+  version,
+  implementation,
+}
+/* Grid Not a pure module */