@sprig-and-prose/sprig-universe 0.1.0

package/src/util/span.js

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Source span utilities for tracking source locations
+ */
+
+/**
+ * @typedef {Object} SourceSpan
+ * @property {string} file - File path
+ * @property {{ line: number, col: number, offset: number }} start - Start position
+ * @property {{ line: number, col: number, offset: number }} end - End position
+ */
+
+/**
+ * Creates a source span from start and end positions
+ * @param {string} file - File path
+ * @param {{ line: number, col: number, offset: number }} start - Start position
+ * @param {{ line: number, col: number, offset: number }} end - End position
+ * @returns {SourceSpan}
+ */
+export function createSpan(file, start, end) {
+  return { file, start, end };
+}
+
+/**
+ * Creates a zero-length span at a position
+ * @param {string} file - File path
+ * @param {{ line: number, col: number, offset: number }} pos - Position
+ * @returns {SourceSpan}
+ */
+export function createPointSpan(file, pos) {
+  return { file, start: pos, end: pos };
+}
+
+/**
+ * Merges two spans (from start of first to end of second)
+ * @param {SourceSpan} span1 - First span
+ * @param {SourceSpan} span2 - Second span
+ * @returns {SourceSpan}
+ */
+export function mergeSpans(span1, span2) {
+  return {
+    file: span1.file,
+    start: span1.start,
+    end: span2.end,
+  };
+}
+

package/src/util/text.js

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview Text normalization utilities
+ */
+
+/**
+ * Counts leading whitespace, treating tabs as 2 spaces.
+ * @param {string} line - Line to count indentation for
+ * @returns {number} - Indentation count (spaces + tabs*2)
+ */
+function countIndent(line) {
+  let count = 0;
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] === ' ') {
+      count++;
+    } else if (line[i] === '\t') {
+      count += 2; // Treat tabs as 2 spaces
+    } else {
+      break;
+    }
+  }
+  return count;
+}
+
+/**
+ * Removes exactly `amount` worth of leading whitespace (spaces/tabs).
+ * Treats tabs as 2 spaces when removing.
+ * @param {string} line - Line to remove indentation from
+ * @param {number} amount - Amount of indentation to remove (in space units)
+ * @returns {string} - Line with indentation removed
+ */
+function removeIndent(line, amount) {
+  let removed = 0;
+  let i = 0;
+  while (i < line.length && removed < amount) {
+    if (line[i] === ' ') {
+      removed++;
+      i++;
+    } else if (line[i] === '\t') {
+      removed += 2; // Treat tabs as 2 spaces
+      i++;
+      // If we overshoot, we've removed the tab, which is fine
+    } else {
+      break;
+    }
+  }
+  return line.slice(i);
+}
+
+/**
+ * Normalizes prose blocks by removing common indentation from lines after the first non-empty line.
+ * This handles the common case where the first line is flush-left (indent 0) and subsequent lines
+ * are indented due to code formatting.
+ *
+ * Algorithm:
+ * 1. Split raw by '\n' into lines
+ * 2. Find the first non-empty line index i0
+ * 3. Compute minIndentAfter from lines AFTER i0 (only non-empty lines)
+ * 4. Keep lines[0..i0] unchanged, then for lines after i0, remove minIndentAfter worth of indentation
+ *
+ * @param {string} raw - Raw text to normalize
+ * @returns {string} - Normalized text
+ */
+export function normalizeProseBlock(raw) {
+  const lines = raw.split('\n');
+
+  // Find first non-empty line index
+  let i0 = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim().length > 0) {
+      i0 = i;
+      break;
+    }
+  }
+
+  // If no non-empty line found, return raw unchanged
+  if (i0 === -1) {
+    return raw;
+  }
+
+  // Compute minIndentAfter from lines AFTER i0 (only non-empty lines)
+  // Use the minimum indent to preserve relative indentation while removing common prefix
+  let minIndentAfter = null;
+  for (let i = i0 + 1; i < lines.length; i++) {
+    if (lines[i].trim().length > 0) {
+      const indent = countIndent(lines[i]);
+      if (minIndentAfter === null || indent < minIndentAfter) {
+        minIndentAfter = indent;
+      }
+    }
+  }
+
+  // If no non-empty lines after i0, return raw unchanged
+  if (minIndentAfter === null || minIndentAfter === 0) {
+    return raw;
+  }
+
+  // Produce output: keep lines[0..i0] unchanged, then remove minIndentAfter from subsequent lines
+  const result = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (i <= i0) {
+      // Keep lines up to and including first non-empty line unchanged
+      result.push(lines[i]);
+    } else {
+      // For lines after i0
+      if (lines[i].trim().length === 0) {
+        // Empty/whitespace-only lines: keep as empty string
+        result.push('');
+      } else {
+        // Remove exactly minIndentAfter worth of indentation
+        result.push(removeIndent(lines[i], minIndentAfter));
+      }
+    }
+  }
+
+  return result.join('\n');
+}
+
+/**
+ * @deprecated Use normalizeProseBlock instead
+ * @param {string} raw - Raw text to dedent
+ * @returns {string} - Dedented text
+ */
+export function dedentPreserve(raw) {
+  return normalizeProseBlock(raw);
+}
+