@intentius/chant 0.0.11 → 0.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "license": "Apache-2.0",
   "type": "module",
   "files": ["src/", "bin/"],

package/src/lsp/lexicon-providers.ts

@@ -108,6 +108,7 @@ export function lexiconCompletions(
   }
 
   // Inside constructor props — look for `new ClassName({` pattern
+  if (!ctx.content) return [];
   const constructorMatch = ctx.content.slice(0, ctx.content.split("\n").slice(0, ctx.position.line + 1).join("\n").length)
     .match(/\bnew\s+(\w+)\s*\(\s*(?:["'][^"']*["']\s*,\s*)?{[^}]*$/s);
 

package/src/yaml.test.ts

@@ -0,0 +1,192 @@
+import { describe, expect, test } from "bun:test";
+import { emitYAML, parseYAML, parseScalar } from "./yaml";
+
+// ---------------------------------------------------------------------------
+// emitYAML
+// ---------------------------------------------------------------------------
+describe("emitYAML", () => {
+  test("null", () => {
+    expect(emitYAML(null, 0)).toBe("null");
+    expect(emitYAML(undefined, 0)).toBe("null");
+  });
+
+  test("booleans", () => {
+    expect(emitYAML(true, 0)).toBe("true");
+    expect(emitYAML(false, 0)).toBe("false");
+  });
+
+  test("numbers", () => {
+    expect(emitYAML(42, 0)).toBe("42");
+    expect(emitYAML(3.14, 0)).toBe("3.14");
+  });
+
+  test("plain strings", () => {
+    expect(emitYAML("hello", 0)).toBe("hello");
+  });
+
+  test("strings requiring quoting", () => {
+    // boolean-like
+    expect(emitYAML("true", 0)).toBe("'true'");
+    expect(emitYAML("yes", 0)).toBe("'yes'");
+    // colon-space
+    expect(emitYAML("key: value", 0)).toBe("'key: value'");
+    // hash
+    expect(emitYAML("a # comment", 0)).toBe("'a # comment'");
+    // leading special chars
+    expect(emitYAML("$VAR", 0)).toBe("'$VAR'");
+    expect(emitYAML("!ref", 0)).toBe("'!ref'");
+    expect(emitYAML("*alias", 0)).toBe("'*alias'");
+    expect(emitYAML("{obj}", 0)).toBe("'{obj}'");
+    expect(emitYAML("[arr]", 0)).toBe("'[arr]'");
+    // leading digit
+    expect(emitYAML("123abc", 0)).toBe("'123abc'");
+    // empty string
+    expect(emitYAML("", 0)).toBe("''");
+  });
+
+  test("single-quote escaping", () => {
+    // A string that needs quoting (leading digit) AND contains a single quote
+    expect(emitYAML("1's", 0)).toBe("'1''s'");
+  });
+
+  test("empty array", () => {
+    expect(emitYAML([], 0)).toBe("[]");
+  });
+
+  test("simple array", () => {
+    const result = emitYAML(["a", "b"], 0);
+    expect(result).toBe("\n- a\n- b");
+  });
+
+  test("array of objects inlines first key on dash line", () => {
+    const result = emitYAML([{ name: "x", value: 1 }], 0);
+    expect(result).toContain("- name: x");
+    expect(result).toContain("  value: 1");
+  });
+
+  test("empty object", () => {
+    expect(emitYAML({}, 0)).toBe("{}");
+  });
+
+  test("nested object", () => {
+    const result = emitYAML({ a: { b: 1 } }, 0);
+    expect(result).toContain("a:");
+    expect(result).toContain("  b: 1");
+  });
+
+  test("tagged value with array", () => {
+    const result = emitYAML({ tag: "!reference", value: [".base", "script"] }, 0);
+    expect(result).toBe("!reference [.base, script]");
+  });
+
+  test("tagged value with scalar", () => {
+    const result = emitYAML({ tag: "!include", value: "file.yml" }, 0);
+    expect(result).toBe("!include file.yml");
+  });
+
+  test("indentation at depth", () => {
+    const result = emitYAML({ key: "val" }, 1);
+    expect(result).toBe("\n  key: val");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseYAML
+// ---------------------------------------------------------------------------
+describe("parseYAML", () => {
+  test("JSON passthrough", () => {
+    const result = parseYAML('{"a": 1}');
+    expect(result).toEqual({ a: 1 });
+  });
+
+  test("simple key-value", () => {
+    const result = parseYAML("name: hello\ncount: 42");
+    expect(result).toEqual({ name: "hello", count: 42 });
+  });
+
+  test("nested object", () => {
+    const result = parseYAML("parent:\n  child: value");
+    expect(result).toEqual({ parent: { child: "value" } });
+  });
+
+  test("block array", () => {
+    const result = parseYAML("items:\n  - a\n  - b\n  - c");
+    expect(result).toEqual({ items: ["a", "b", "c"] });
+  });
+
+  test("inline array", () => {
+    const result = parseYAML('items: ["a", "b"]');
+    expect(result).toEqual({ items: ["a", "b"] });
+  });
+
+  test("inline object", () => {
+    const result = parseYAML('data: {"x": 1}');
+    expect(result).toEqual({ data: { x: 1 } });
+  });
+
+  test("comments and blank lines are skipped", () => {
+    const result = parseYAML("# comment\na: 1\n\n# another\nb: 2");
+    expect(result).toEqual({ a: 1, b: 2 });
+  });
+
+  test("scalar coercion", () => {
+    const result = parseYAML("a: true\nb: false\nc: null\nd: yes\ne: no\nf: ~");
+    expect(result).toEqual({ a: true, b: false, c: null, d: true, e: false, f: null });
+  });
+
+  test("quoted strings preserve value", () => {
+    const result = parseYAML("a: 'true'\nb: \"42\"");
+    expect(result).toEqual({ a: "true", b: "42" });
+  });
+
+  test("handles CRLF line endings", () => {
+    const result = parseYAML("apiVersion: v1\r\nkind: Pod\r\nmetadata:\r\n  name: test\r\n");
+    expect(result).toEqual({
+      apiVersion: "v1",
+      kind: "Pod",
+      metadata: { name: "test" },
+    });
+  });
+
+  test("handles bare CR line endings", () => {
+    const result = parseYAML("a: 1\rb: 2\r");
+    expect(result).toEqual({ a: 1, b: 2 });
+  });
+
+  test("array of objects", () => {
+    const result = parseYAML("items:\n  - name: x\n    value: 1\n  - name: y\n    value: 2");
+    expect(result).toEqual({
+      items: [
+        { name: "x", value: 1 },
+        { name: "y", value: 2 },
+      ],
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseScalar
+// ---------------------------------------------------------------------------
+describe("parseScalar", () => {
+  test("null variants", () => {
+    expect(parseScalar("")).toBe(null);
+    expect(parseScalar("~")).toBe(null);
+    expect(parseScalar("null")).toBe(null);
+  });
+
+  test("boolean variants", () => {
+    expect(parseScalar("true")).toBe(true);
+    expect(parseScalar("yes")).toBe(true);
+    expect(parseScalar("false")).toBe(false);
+    expect(parseScalar("no")).toBe(false);
+  });
+
+  test("numbers", () => {
+    expect(parseScalar("42")).toBe(42);
+    expect(parseScalar("3.14")).toBe(3.14);
+  });
+
+  test("plain strings", () => {
+    expect(parseScalar("hello")).toBe("hello");
+  });
+});

package/src/yaml.ts

@@ -0,0 +1,308 @@
+/**
+ * Lightweight YAML emitter and parser.
+ *
+ * Covers the subset of YAML used by Chant lexicons (scalars, block arrays,
+ * nested objects, tagged values). Not a full YAML implementation — use a
+ * dedicated library if you need anchors, multi-document streams, or
+ * block scalars.
+ */
+
+// ---------------------------------------------------------------------------
+// Emitter
+// ---------------------------------------------------------------------------
+
+/**
+ * Emit a YAML value with proper indentation.
+ *
+ * - Primitives render inline.
+ * - Arrays and objects render as block YAML, returning a string that starts
+ *   with `\n` so the caller can append it after a key.
+ * - Tagged values `{ tag, value }` emit `!tag [...]` or `!tag scalar`.
+ */
+export function emitYAML(value: unknown, indent: number): string {
+  const prefix = "  ".repeat(indent);
+
+  if (value === null || value === undefined) {
+    return "null";
+  }
+
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+
+  if (typeof value === "number") {
+    return String(value);
+  }
+
+  if (typeof value === "string") {
+    // Quote strings that could be misinterpreted
+    if (
+      value === "" ||
+      value === "true" ||
+      value === "false" ||
+      value === "null" ||
+      value === "yes" ||
+      value === "no" ||
+      value.includes(": ") ||
+      value.includes("#") ||
+      value.startsWith("*") ||
+      value.startsWith("&") ||
+      value.startsWith("!") ||
+      value.startsWith("{") ||
+      value.startsWith("[") ||
+      value.startsWith("'") ||
+      value.startsWith('"') ||
+      value.startsWith("$") ||
+      /^\d/.test(value)
+    ) {
+      // Use single quotes, escaping internal single quotes
+      return `'${value.replace(/'/g, "''")}'`;
+    }
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const lines: string[] = [];
+    for (const item of value) {
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        // Object items in arrays
+        const entries = Object.entries(item as Record<string, unknown>);
+        if (entries.length > 0) {
+          const [firstKey, firstVal] = entries[0];
+          const firstEmitted = emitYAML(firstVal, indent + 2);
+          if (firstEmitted.startsWith("\n")) {
+            lines.push(`${prefix}- ${firstKey}:${firstEmitted}`);
+          } else {
+            lines.push(`${prefix}- ${firstKey}: ${firstEmitted}`);
+          }
+          for (let i = 1; i < entries.length; i++) {
+            const [key, val] = entries[i];
+            const emitted = emitYAML(val, indent + 2);
+            if (emitted.startsWith("\n")) {
+              lines.push(`${prefix}  ${key}:${emitted}`);
+            } else {
+              lines.push(`${prefix}  ${key}: ${emitted}`);
+            }
+          }
+        }
+      } else {
+        lines.push(`${prefix}- ${emitYAML(item, indent + 1).trimStart()}`);
+      }
+    }
+    return "\n" + lines.join("\n");
+  }
+
+  if (typeof value === "object") {
+    const obj = value as Record<string, unknown>;
+
+    // Handle tagged values (e.g. { tag: "!reference", value: [...] })
+    if ("tag" in obj && "value" in obj && typeof obj.tag === "string") {
+      if (Array.isArray(obj.value)) {
+        return `${obj.tag} [${(obj.value as unknown[]).map(String).join(", ")}]`;
+      }
+      return `${obj.tag} ${emitYAML(obj.value, indent)}`;
+    }
+
+    const entries = Object.entries(obj);
+    if (entries.length === 0) return "{}";
+    const lines: string[] = [];
+    for (const [key, val] of entries) {
+      const emitted = emitYAML(val, indent + 1);
+      if (emitted.startsWith("\n")) {
+        lines.push(`${prefix}${key}:${emitted}`);
+      } else {
+        lines.push(`${prefix}${key}: ${emitted}`);
+      }
+    }
+    return "\n" + lines.join("\n");
+  }
+
+  return String(value);
+}
+
+// ---------------------------------------------------------------------------
+// Parser
+// ---------------------------------------------------------------------------
+
+/** Result of parsing a YAML block. */
+export interface ParseResult {
+  value: unknown;
+  endIndex: number;
+}
+
+/**
+ * Parse a YAML document (or JSON document) into a plain object.
+ *
+ * Tries `JSON.parse` first; falls back to a line-based YAML parser that
+ * handles the subset of YAML commonly found in CI configuration files.
+ */
+export function parseYAML(content: string): Record<string, unknown> {
+  try {
+    return JSON.parse(content);
+  } catch {
+    // Fall through to YAML parsing
+  }
+
+  const lines = content.replace(/\r\n?/g, "\n").split("\n");
+  return parseYAMLLines(lines, 0, 0).value as Record<string, unknown>;
+}
+
+/**
+ * Parse indentation-based YAML lines into a key-value object.
+ */
+export function parseYAMLLines(
+  lines: string[],
+  startIndex: number,
+  baseIndent: number,
+): ParseResult {
+  const result: Record<string, unknown> = {};
+  let i = startIndex;
+
+  while (i < lines.length) {
+    const line = lines[i];
+    // Skip empty lines and comments
+    if (line.trim() === "" || line.trim().startsWith("#")) {
+      i++;
+      continue;
+    }
+
+    const indent = line.search(/\S/);
+    if (indent < baseIndent) break; // Dedented — done with this block
+    if (indent > baseIndent && startIndex > 0) break; // Unexpected indent
+
+    const keyMatch = line.match(/^(\s*)([^\s:][^:]*?):\s*(.*)$/);
+    if (keyMatch) {
+      const key = keyMatch[2].trim();
+      const inlineValue = keyMatch[3].trim();
+
+      if (inlineValue === "" || inlineValue.startsWith("#")) {
+        // Check next line for array or nested object
+        if (i + 1 < lines.length) {
+          const nextLine = lines[i + 1];
+          const nextIndent = nextLine.search(/\S/);
+          if (nextIndent > indent && nextLine.trimStart().startsWith("- ")) {
+            const arr = parseYAMLArray(lines, i + 1, nextIndent);
+            result[key] = arr.value;
+            i = arr.endIndex;
+            continue;
+          } else if (nextIndent > indent) {
+            const nested = parseYAMLLines(lines, i + 1, nextIndent);
+            result[key] = nested.value;
+            i = nested.endIndex;
+            continue;
+          }
+        }
+        result[key] = null;
+        i++;
+      } else if (inlineValue.startsWith("[")) {
+        // Inline array
+        try {
+          result[key] = JSON.parse(inlineValue);
+        } catch {
+          result[key] = inlineValue;
+        }
+        i++;
+      } else if (inlineValue.startsWith("{")) {
+        // Inline object
+        try {
+          result[key] = JSON.parse(inlineValue);
+        } catch {
+          result[key] = inlineValue;
+        }
+        i++;
+      } else {
+        result[key] = parseScalar(inlineValue);
+        i++;
+      }
+    } else if (line.trimStart().startsWith("- ")) {
+      break;
+    } else {
+      i++;
+    }
+  }
+
+  return { value: result, endIndex: i };
+}
+
+/**
+ * Parse a block array (lines starting with `- `).
+ */
+export function parseYAMLArray(
+  lines: string[],
+  startIndex: number,
+  baseIndent: number,
+): ParseResult {
+  const result: unknown[] = [];
+  let i = startIndex;
+
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "" || line.trim().startsWith("#")) {
+      i++;
+      continue;
+    }
+
+    const indent = line.search(/\S/);
+    if (indent < baseIndent) break;
+
+    const itemMatch = line.match(/^(\s*)- (.*)$/);
+    if (itemMatch && indent === baseIndent) {
+      const itemValue = itemMatch[2].trim();
+      // Check if it's a key-value pair (object item in array)
+      const kvMatch = itemValue.match(/^([^\s:][^:]*?):\s*(.*)$/);
+      if (kvMatch) {
+        const obj: Record<string, unknown> = {};
+        obj[kvMatch[1].trim()] = parseScalar(kvMatch[2].trim());
+        // Check for more keys at indent+2
+        const nextIndent = indent + 2;
+        let j = i + 1;
+        while (j < lines.length) {
+          const nextLine = lines[j];
+          if (nextLine.trim() === "" || nextLine.trim().startsWith("#")) {
+            j++;
+            continue;
+          }
+          const ni = nextLine.search(/\S/);
+          if (ni !== nextIndent) break;
+          const nextKV = nextLine.match(/^(\s*)([^\s:][^:]*?):\s*(.*)$/);
+          if (nextKV) {
+            obj[nextKV[2].trim()] = parseScalar(nextKV[3].trim());
+            j++;
+          } else {
+            break;
+          }
+        }
+        result.push(obj);
+        i = j;
+      } else {
+        result.push(parseScalar(itemValue));
+        i++;
+      }
+    } else {
+      break;
+    }
+  }
+
+  return { value: result, endIndex: i };
+}
+
+/**
+ * Coerce a scalar string to a typed value.
+ */
+export function parseScalar(value: string): unknown {
+  if (value === "" || value === "~" || value === "null") return null;
+  if (value === "true" || value === "yes") return true;
+  if (value === "false" || value === "no") return false;
+  // Strip quotes
+  if (
+    (value.startsWith("'") && value.endsWith("'")) ||
+    (value.startsWith('"') && value.endsWith('"'))
+  ) {
+    return value.slice(1, -1);
+  }
+  // Number
+  const num = Number(value);
+  if (!isNaN(num) && value !== "") return num;
+  return value;
+}