wyreframe 0.2.2 → 0.4.0

package/src/parser/Fixer/FixTypes.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/parser/Fixer/FixTypes.res

@@ -0,0 +1,34 @@
+// FixTypes.res
+// Type definitions for the auto-fix functionality
+
+/**
+ * Describes a single fix that was applied to the source text
+ */
+type fixedIssue = {
+  original: ErrorTypes.t,
+  description: string,
+  line: int,
+  column: int,
+}
+
+/**
+ * Result of a successful fix operation
+ */
+type fixSuccess = {
+  text: string,
+  fixed: array<fixedIssue>,
+  remaining: array<ErrorTypes.t>,
+}
+
+/**
+ * Result type for fix operations
+ */
+type fixResult = result<fixSuccess, array<ErrorTypes.t>>
+
+/**
+ * Strategy for fixing a specific error type
+ */
+type fixStrategy = {
+  canFix: ErrorTypes.errorCode => bool,
+  apply: (string, ErrorTypes.t) => option<(string, fixedIssue)>,
+}

package/src/parser/Fixer/Fixer.gen.tsx

@@ -0,0 +1,24 @@
+/* TypeScript file generated from Fixer.res by genType. */
+
+/* eslint-disable */
+/* tslint:disable */
+
+import * as FixerJS from './Fixer.mjs';
+
+import type {fixResult as FixTypes_fixResult} from './FixTypes.gen';
+
+/** * Main fix function - attempts to fix all errors in the text
+ *
+ * This function:
+ * 1. Parses the text to get errors/warnings
+ * 2. Attempts to fix each fixable error
+ * 3. Re-parses after each fix to get updated positions
+ * 4. Returns the fixed text and list of applied fixes
+ *
+ * @param text The wireframe markdown text
+ * @returns FixResult with fixed text and details */
+export const fix: (text:string) => FixTypes_fixResult = FixerJS.fix as any;
+
+/** * Convenience function - fix and return just the fixed text
+ * Returns the original text if nothing was fixed */
+export const fixOnly: (text:string) => string = FixerJS.fixOnly as any;

package/src/parser/Fixer/Fixer.mjs

@@ -0,0 +1,447 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Parser from "../Parser.mjs";
+import * as Core__Array from "@rescript/core/src/Core__Array.mjs";
+
+function splitLines(text) {
+  return text.split("\n");
+}
+
+function joinLines(lines) {
+  return lines.join("\n");
+}
+
+function getLine(lines, row) {
+  return lines[row];
+}
+
+function replaceLine(lines, row, newLine) {
+  return lines.map((line, idx) => {
+    if (idx === row) {
+      return newLine;
+    } else {
+      return line;
+    }
+  });
+}
+
+function insertAt(str, col, chars) {
+  let before = str.slice(0, col);
+  let after = str.slice(col);
+  return before + chars + after;
+}
+
+function removeAt(str, col, count) {
+  let before = str.slice(0, col);
+  let after = str.slice(col + count | 0);
+  return before + after;
+}
+
+function replaceCharAt(str, col, char) {
+  let before = str.slice(0, col);
+  let after = str.slice(col + 1 | 0);
+  return before + char + after;
+}
+
+function fixMisalignedPipe(text, error) {
+  let match = error.code;
+  if (match.TAG !== "MisalignedPipe") {
+    return;
+  }
+  let actualCol = match.actualCol;
+  let expectedCol = match.expectedCol;
+  let position = match.position;
+  let lines = text.split("\n");
+  let line = lines[position.row];
+  if (line === undefined) {
+    return;
+  }
+  let diff = expectedCol - actualCol | 0;
+  let newLine;
+  if (diff > 0) {
+    newLine = insertAt(line, actualCol, " ".repeat(diff));
+  } else {
+    let removeCount = Math.abs(diff);
+    let beforePipe = line.slice(actualCol + diff | 0, actualCol);
+    newLine = beforePipe.trim() === "" ? removeAt(line, actualCol + diff | 0, removeCount) : line;
+  }
+  if (newLine === line) {
+    return;
+  }
+  let newLines = replaceLine(lines, position.row, newLine);
+  let fixedText = newLines.join("\n");
+  return [
+    fixedText,
+    {
+      original: error,
+      description: `Aligned pipe at line ` + (position.row + 1 | 0).toString() + ` to column ` + (expectedCol + 1 | 0).toString(),
+      line: position.row + 1 | 0,
+      column: expectedCol + 1 | 0
+    }
+  ];
+}
+
+function fixMisalignedClosingBorder(text, error) {
+  let match = error.code;
+  if (match.TAG !== "MisalignedClosingBorder") {
+    return;
+  }
+  let actualCol = match.actualCol;
+  let expectedCol = match.expectedCol;
+  let position = match.position;
+  let lines = text.split("\n");
+  let line = lines[position.row];
+  if (line === undefined) {
+    return;
+  }
+  let diff = expectedCol - actualCol | 0;
+  let newLine;
+  if (diff > 0) {
+    newLine = insertAt(line, actualCol, " ".repeat(diff));
+  } else {
+    let removeCount = Math.abs(diff);
+    let beforePipe = line.slice(actualCol + diff | 0, actualCol);
+    newLine = beforePipe.trim() === "" ? removeAt(line, actualCol + diff | 0, removeCount) : line;
+  }
+  if (newLine === line) {
+    return;
+  }
+  let newLines = replaceLine(lines, position.row, newLine);
+  let fixedText = newLines.join("\n");
+  return [
+    fixedText,
+    {
+      original: error,
+      description: `Aligned closing border at line ` + (position.row + 1 | 0).toString() + ` to column ` + (expectedCol + 1 | 0).toString(),
+      line: position.row + 1 | 0,
+      column: expectedCol + 1 | 0
+    }
+  ];
+}
+
+function fixUnusualSpacing(text, error) {
+  let match = error.code;
+  if (match.TAG !== "UnusualSpacing") {
+    return;
+  }
+  let issue = match.issue;
+  if (!(issue.includes("tab") || issue.includes("Tab"))) {
+    return;
+  }
+  let position = match.position;
+  let lines = text.split("\n");
+  let line = lines[position.row];
+  if (line === undefined) {
+    return;
+  }
+  let newLine = line.replaceAll("\t", "  ");
+  if (newLine === line) {
+    return;
+  }
+  let newLines = replaceLine(lines, position.row, newLine);
+  let fixedText = newLines.join("\n");
+  return [
+    fixedText,
+    {
+      original: error,
+      description: `Replaced tabs with spaces at line ` + (position.row + 1 | 0).toString(),
+      line: position.row + 1 | 0,
+      column: position.col + 1 | 0
+    }
+  ];
+}
+
+function fixUnclosedBracket(text, error) {
+  let match = error.code;
+  if (match.TAG !== "UnclosedBracket") {
+    return;
+  }
+  let opening = match.opening;
+  let lines = text.split("\n");
+  let line = lines[opening.row];
+  if (line === undefined) {
+    return;
+  }
+  let trimmedLine = line.trimEnd();
+  if (trimmedLine.endsWith("]")) {
+    return;
+  }
+  let newLine = trimmedLine + " ]";
+  let newLines = replaceLine(lines, opening.row, newLine);
+  let fixedText = newLines.join("\n");
+  return [
+    fixedText,
+    {
+      original: error,
+      description: `Added closing bracket at line ` + (opening.row + 1 | 0).toString(),
+      line: opening.row + 1 | 0,
+      column: trimmedLine.length + 2 | 0
+    }
+  ];
+}
+
+function fixMismatchedWidth(text, error) {
+  let match = error.code;
+  if (match.TAG !== "MismatchedWidth") {
+    return;
+  }
+  let bottomWidth = match.bottomWidth;
+  let topWidth = match.topWidth;
+  let topLeft = match.topLeft;
+  let lines = text.split("\n");
+  let diff = topWidth - bottomWidth | 0;
+  if (diff === 0) {
+    return;
+  }
+  let findBottomRow = _row => {
+    while (true) {
+      let row = _row;
+      if (row >= lines.length) {
+        return;
+      }
+      let line = lines[row];
+      if (line === undefined) {
+        return;
+      }
+      let col = topLeft.col;
+      if (col < line.length) {
+        let char = line.charAt(col);
+        if (char === "+" && row > topLeft.row) {
+          return row;
+        }
+        _row = row + 1 | 0;
+        continue;
+      }
+      _row = row + 1 | 0;
+      continue;
+    };
+  };
+  let bottomRow = findBottomRow(topLeft.row + 1 | 0);
+  if (bottomRow === undefined) {
+    return;
+  }
+  let bottomLine = lines[bottomRow];
+  if (bottomLine === undefined) {
+    return;
+  }
+  if (diff > 0) {
+    let closingPlusCol = (topLeft.col + bottomWidth | 0) - 1 | 0;
+    if (!(closingPlusCol >= 0 && closingPlusCol < bottomLine.length)) {
+      return;
+    }
+    let before = bottomLine.slice(0, closingPlusCol);
+    let after = bottomLine.slice(closingPlusCol);
+    let dashes = "-".repeat(diff);
+    let newLine = before + dashes + after;
+    let newLines = replaceLine(lines, bottomRow, newLine);
+    let fixedText = newLines.join("\n");
+    return [
+      fixedText,
+      {
+        original: error,
+        description: `Extended bottom border at line ` + (bottomRow + 1 | 0).toString() + ` by ` + diff.toString() + ` characters`,
+        line: bottomRow + 1 | 0,
+        column: closingPlusCol + 1 | 0
+      }
+    ];
+  }
+  let topLine = lines[topLeft.row];
+  if (topLine === undefined) {
+    return;
+  }
+  let closingPlusCol$1 = (topLeft.col + topWidth | 0) - 1 | 0;
+  if (!(closingPlusCol$1 >= 0 && closingPlusCol$1 < topLine.length)) {
+    return;
+  }
+  let before$1 = topLine.slice(0, closingPlusCol$1);
+  let after$1 = topLine.slice(closingPlusCol$1);
+  let dashes$1 = "-".repeat(Math.abs(diff));
+  let newLine$1 = before$1 + dashes$1 + after$1;
+  let newLines$1 = replaceLine(lines, topLeft.row, newLine$1);
+  let fixedText$1 = newLines$1.join("\n");
+  return [
+    fixedText$1,
+    {
+      original: error,
+      description: `Extended top border at line ` + (topLeft.row + 1 | 0).toString() + ` by ` + Math.abs(diff).toString() + ` characters`,
+      line: topLeft.row + 1 | 0,
+      column: closingPlusCol$1 + 1 | 0
+    }
+  ];
+}
+
+let fixStrategies = [
+  [
+    "MisalignedPipe",
+    code => code.TAG === "MisalignedPipe",
+    fixMisalignedPipe
+  ],
+  [
+    "MisalignedClosingBorder",
+    code => code.TAG === "MisalignedClosingBorder",
+    fixMisalignedClosingBorder
+  ],
+  [
+    "UnusualSpacing",
+    code => code.TAG === "UnusualSpacing",
+    fixUnusualSpacing
+  ],
+  [
+    "UnclosedBracket",
+    code => code.TAG === "UnclosedBracket",
+    fixUnclosedBracket
+  ],
+  [
+    "MismatchedWidth",
+    code => code.TAG === "MismatchedWidth",
+    fixMismatchedWidth
+  ]
+];
+
+function tryFixError(text, error) {
+  return Core__Array.reduce(fixStrategies, undefined, (acc, param) => {
+    if (acc !== undefined) {
+      return acc;
+    } else if (param[1](error.code)) {
+      return param[2](text, error);
+    } else {
+      return;
+    }
+  });
+}
+
+function isFixable(code) {
+  return fixStrategies.some(param => param[1](code));
+}
+
+function fix(text) {
+  let _currentText = text;
+  let _fixedSoFar = [];
+  let _iteration = 0;
+  while (true) {
+    let iteration = _iteration;
+    let fixedSoFar = _fixedSoFar;
+    let currentText = _currentText;
+    if (iteration >= 100) {
+      return {
+        TAG: "Ok",
+        _0: {
+          text: currentText,
+          fixed: fixedSoFar,
+          remaining: []
+        }
+      };
+    }
+    let parseResult = Parser.parse(currentText);
+    if (parseResult.TAG === "Ok") {
+      let warnings = parseResult._0[1];
+      let fixableWarnings = warnings.filter(w => isFixable(w.code));
+      if (fixableWarnings.length === 0) {
+        return {
+          TAG: "Ok",
+          _0: {
+            text: currentText,
+            fixed: fixedSoFar,
+            remaining: warnings.filter(w => !isFixable(w.code))
+          }
+        };
+      }
+      let warning = fixableWarnings[0];
+      if (warning === undefined) {
+        return {
+          TAG: "Ok",
+          _0: {
+            text: currentText,
+            fixed: fixedSoFar,
+            remaining: warnings
+          }
+        };
+      }
+      let match = tryFixError(currentText, warning);
+      if (match === undefined) {
+        return {
+          TAG: "Ok",
+          _0: {
+            text: currentText,
+            fixed: fixedSoFar,
+            remaining: warnings
+          }
+        };
+      }
+      let newFixed = fixedSoFar.concat([match[1]]);
+      _iteration = iteration + 1 | 0;
+      _fixedSoFar = newFixed;
+      _currentText = match[0];
+      continue;
+    }
+    let errors = parseResult._0;
+    let fixableErrors = errors.filter(e => isFixable(e.code));
+    if (fixableErrors.length === 0) {
+      return {
+        TAG: "Ok",
+        _0: {
+          text: currentText,
+          fixed: fixedSoFar,
+          remaining: errors.filter(e => !isFixable(e.code))
+        }
+      };
+    }
+    let error = fixableErrors[0];
+    if (error === undefined) {
+      return {
+        TAG: "Ok",
+        _0: {
+          text: currentText,
+          fixed: fixedSoFar,
+          remaining: errors
+        }
+      };
+    }
+    let match$1 = tryFixError(currentText, error);
+    if (match$1 === undefined) {
+      return {
+        TAG: "Ok",
+        _0: {
+          text: currentText,
+          fixed: fixedSoFar,
+          remaining: errors
+        }
+      };
+    }
+    let newFixed$1 = fixedSoFar.concat([match$1[1]]);
+    _iteration = iteration + 1 | 0;
+    _fixedSoFar = newFixed$1;
+    _currentText = match$1[0];
+    continue;
+  };
+}
+
+function fixOnly(text) {
+  let match = fix(text);
+  if (match.TAG === "Ok") {
+    return match._0.text;
+  } else {
+    return text;
+  }
+}
+
+export {
+  splitLines,
+  joinLines,
+  getLine,
+  replaceLine,
+  insertAt,
+  removeAt,
+  replaceCharAt,
+  fixMisalignedPipe,
+  fixMisalignedClosingBorder,
+  fixUnusualSpacing,
+  fixUnclosedBracket,
+  fixMismatchedWidth,
+  fixStrategies,
+  tryFixError,
+  isFixable,
+  fix,
+  fixOnly,
+}
+/* Parser Not a pure module */