@kontor/kontor-sdk 1.0.0-alpha.39 → 1.0.0-alpha.40

package/src/sdk/utils/wit/codecs/util.test.ts

@@ -0,0 +1,221 @@
+import { describe, it, expect } from "vitest";
+
+import {
+  stripOuter,
+  parseConstructorCall,
+  findMatchingParenIndex,
+  splitTopLevelComma,
+  splitTopLevelColon,
+} from "./util.js";
+
+describe("wave-parse helpers", () => {
+  describe("stripOuter", () => {
+    it("strips outer delimiters and trims inner", () => {
+      expect(stripOuter("  { a: 1 }  ", "{", "}")).toEqual({
+        inner: "a: 1",
+        hadOuter: true,
+      });
+    });
+
+    it("returns trimmed string when delimiters not present", () => {
+      expect(stripOuter("  a: 1  ", "{", "}")).toEqual({
+        inner: "a: 1",
+        hadOuter: false,
+      });
+    });
+
+    it("does not strip if only opening matches", () => {
+      expect(stripOuter("{ a: 1  ", "{", "}")).toEqual({
+        inner: "{ a: 1",
+        hadOuter: false,
+      });
+    });
+
+    it("does not strip if only closing matches", () => {
+      expect(stripOuter("  a: 1 }", "{", "}")).toEqual({
+        inner: "a: 1 }",
+        hadOuter: false,
+      });
+    });
+
+    it("supports multi-character delimiters", () => {
+      expect(stripOuter("  ok( 123 ) ", "ok(", ")")).toEqual({
+        inner: "123",
+        hadOuter: true,
+      });
+    });
+
+    it("strips even if inner is empty", () => {
+      expect(stripOuter("  (   ) ", "(", ")")).toEqual({
+        inner: "",
+        hadOuter: true,
+      });
+    });
+  });
+
+  describe("findMatchingParenIndex", () => {
+    it("finds matching closing paren for simple expression", () => {
+      const s = "(abc)";
+      expect(findMatchingParenIndex(s, 0)).toBe(4);
+    });
+
+    it("handles nested parentheses", () => {
+      const s = "(a(b)c)";
+      // indices: 0 '(' ... 6 ')'
+      expect(findMatchingParenIndex(s, 0)).toBe(6);
+    });
+
+    it("handles nested braces and brackets inside parens", () => {
+      const s = "({x: [1, 2, (3)]})";
+      expect(findMatchingParenIndex(s, 0)).toBe(s.length - 1);
+    });
+    it("ignores parentheses inside quoted strings", () => {
+      const s = '(")")';
+      expect(findMatchingParenIndex(s, 0)).toBe(s.length - 1);
+    });
+
+    it("handles escaped quotes inside strings", () => {
+      const s = '("a \\" ) \\" b")';
+      expect(findMatchingParenIndex(s, 0)).toBe(s.length - 1);
+    });
+
+    it("throws if openIndex is not '('", () => {
+      expect(() => findMatchingParenIndex("abc", 0)).toThrow(
+        "internal: expected '('",
+      );
+    });
+
+    it("throws on missing closing paren", () => {
+      expect(() => findMatchingParenIndex("(abc", 0)).toThrow(
+        "missing closing ')'",
+      );
+    });
+  });
+
+  describe("parseConstructorCall", () => {
+    it("parses name only", () => {
+      expect(parseConstructorCall("none")).toEqual({ name: "none", arg: null });
+    });
+
+    it("parses name + argument", () => {
+      expect(parseConstructorCall("some( 123 )")).toEqual({
+        name: "some",
+        arg: "123",
+      });
+    });
+
+    it("parses nested argument with braces/brackets/parens", () => {
+      expect(
+        parseConstructorCall('ok({r0: 7, r1: 0, inner: [1, (2)], s: "a,b"})'),
+      ).toEqual({
+        name: "ok",
+        arg: '{r0: 7, r1: 0, inner: [1, (2)], s: "a,b"}',
+      });
+    });
+
+    it("returns null arg for empty parens", () => {
+      expect(parseConstructorCall("some(   )")).toEqual({
+        name: "some",
+        arg: null,
+      });
+    });
+
+    it("throws when missing '(' after name but has trailing stuff", () => {
+      expect(() => parseConstructorCall("some 123")).toThrow(
+        'expected "(" after constructor name "some"',
+      );
+    });
+
+    it("throws when trailing junk exists after closing paren", () => {
+      expect(() => parseConstructorCall("some(1) )")).toThrow(
+        'unexpected trailing characters after some(...): ")"',
+      );
+    });
+
+    it("throws on invalid constructor expression", () => {
+      expect(() => parseConstructorCall("  123")).toThrow(
+        'invalid constructor expression: "  123"',
+      );
+    });
+    expect(() => parseConstructorCall("some(1))")).toThrow(
+      'unexpected trailing characters after some(...): ")"',
+    );
+  });
+
+  describe("splitTopLevelComma", () => {
+    it("splits simple comma-separated values", () => {
+      expect(splitTopLevelComma("a, b, c")).toEqual(["a", "b", "c"]);
+    });
+
+    it("does not split inside parentheses", () => {
+      expect(splitTopLevelComma("a, f(1,2), c")).toEqual(["a", "f(1,2)", "c"]);
+    });
+
+    it("does not split inside braces", () => {
+      expect(splitTopLevelComma("a, {x: 1, y: 2}, c")).toEqual([
+        "a",
+        "{x: 1, y: 2}",
+        "c",
+      ]);
+    });
+
+    it("does not split inside brackets", () => {
+      expect(splitTopLevelComma("a, [1,2,3], c")).toEqual([
+        "a",
+        "[1,2,3]",
+        "c",
+      ]);
+    });
+
+    it("does not split inside quoted strings", () => {
+      expect(splitTopLevelComma('"a,b", c, "d,e"')).toEqual([
+        '"a,b"',
+        "c",
+        '"d,e"',
+      ]);
+    });
+
+    it("handles escaped quotes within strings", () => {
+      expect(splitTopLevelComma('"a,\\"b\\"", c')).toEqual([
+        '"a,\\"b\\""',
+        "c",
+      ]);
+    });
+
+    it("drops empty segments (consecutive commas)", () => {
+      expect(splitTopLevelComma("a,, b, , c")).toEqual(["a", "b", "c"]);
+    });
+
+    it("returns [] when inner is empty or whitespace", () => {
+      expect(splitTopLevelComma("")).toEqual([]);
+      expect(splitTopLevelComma("   ")).toEqual([]);
+    });
+  });
+
+  describe("splitTopLevelColon", () => {
+    it("splits key:value at the top level", () => {
+      expect(splitTopLevelColon("r0: 7")).toEqual(["r0", "7"]);
+    });
+
+    it("does not split on colons inside braces/brackets/parens", () => {
+      expect(splitTopLevelColon('k: {a: 1, b: "x:y"}')).toEqual([
+        "k",
+        '{a: 1, b: "x:y"}',
+      ]);
+    });
+
+    it("does not split on colon inside quoted strings", () => {
+      expect(splitTopLevelColon('k: "a:b:c"')).toEqual(["k", '"a:b:c"']);
+    });
+
+    it("trims both sides", () => {
+      expect(splitTopLevelColon("  k  :   v  ")).toEqual(["k", "v"]);
+    });
+
+    it("throws if no top-level colon exists", () => {
+      expect(() => splitTopLevelColon("nope")).toThrow(
+        'expected "key: value", got "nope"',
+      );
+    });
+  });
+});

package/src/sdk/utils/wit/codecs/util.ts

@@ -0,0 +1,193 @@
+export function stripOuter(
+  s: string,
+  open: string,
+  close: string,
+): { inner: string; hadOuter: boolean } {
+  const t = s.trim();
+  if (t.startsWith(open) && t.endsWith(close)) {
+    return {
+      inner: t.slice(open.length, t.length - close.length).trim(),
+      hadOuter: true,
+    };
+  }
+  return { inner: t, hadOuter: false };
+}
+
+export function parseConstructorCall(expr: string): {
+  name: string;
+  arg: string | null;
+} {
+  const s = expr.trim();
+  const m = /^([a-zA-Z_][a-zA-Z0-9_]*)\s*(.*)$/.exec(s);
+  if (!m) throw new Error(`invalid constructor expression: "${expr}"`);
+
+  const name = m[1]!;
+  const rest = m[2]!.trim();
+  if (rest === "") return { name, arg: null };
+
+  if (!rest.startsWith("(")) {
+    throw new Error(`expected "(" after constructor name "${name}": "${expr}"`);
+  }
+
+  const end = findMatchingParenIndex(rest, 0);
+  const arg = rest.slice(1, end).trim();
+  const trailing = rest.slice(end + 1).trim();
+  if (trailing.length !== 0) {
+    throw new Error(
+      `unexpected trailing characters after ${name}(...): "${trailing}"`,
+    );
+  }
+
+  return { name, arg: arg === "" ? null : arg };
+}
+
+// Finds matching ')' for '(' at openIndex, respecting nested (), {}, [], and quoted strings.
+export function findMatchingParenIndex(s: string, openIndex: number): number {
+  if (s[openIndex] !== "(") throw new Error("internal: expected '('");
+
+  let paren = 0;
+  let brace = 0;
+  let bracket = 0;
+  let inString = false;
+  let escape = false;
+
+  for (let i = openIndex; i < s.length; i++) {
+    const ch = s[i]!;
+
+    if (inString) {
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escape = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+
+    if (ch === "(") paren++;
+    else if (ch === ")") {
+      paren--;
+      if (paren === 0 && brace === 0 && bracket === 0) return i;
+      if (paren < 0) throw new Error("unbalanced parentheses");
+    } else if (ch === "{") brace++;
+    else if (ch === "}") brace--;
+    else if (ch === "[") bracket++;
+    else if (ch === "]") bracket--;
+  }
+
+  throw new Error("missing closing ')'");
+}
+
+// Split a string by top-level commas, respecting nested delimiters + strings.
+export function splitTopLevelComma(inner: string): string[] {
+  const out: string[] = [];
+
+  let paren = 0;
+  let brace = 0;
+  let bracket = 0;
+  let inString = false;
+  let escape = false;
+
+  let cur = "";
+
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i]!;
+
+    if (inString) {
+      cur += ch;
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escape = true;
+        continue;
+      }
+      if (ch === '"') inString = false;
+      continue;
+    }
+
+    if (ch === '"') {
+      inString = true;
+      cur += ch;
+      continue;
+    }
+
+    if (ch === "(") paren++;
+    else if (ch === ")") paren--;
+    else if (ch === "{") brace++;
+    else if (ch === "}") brace--;
+    else if (ch === "[") bracket++;
+    else if (ch === "]") bracket--;
+
+    if (ch === "," && paren === 0 && brace === 0 && bracket === 0) {
+      const piece = cur.trim();
+      if (piece) out.push(piece);
+      cur = "";
+      continue;
+    }
+
+    cur += ch;
+  }
+
+  const last = cur.trim();
+  if (last) out.push(last);
+
+  return out;
+}
+
+// Split `key: value` at the first top-level colon (rarely necessary, but safe).
+export function splitTopLevelColon(part: string): [string, string] {
+  const s = part.trim();
+
+  let paren = 0;
+  let brace = 0;
+  let bracket = 0;
+  let inString = false;
+  let escape = false;
+
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i]!;
+
+    if (inString) {
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escape = true;
+        continue;
+      }
+      if (ch === '"') inString = false;
+      continue;
+    }
+
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+
+    if (ch === "(") paren++;
+    else if (ch === ")") paren--;
+    else if (ch === "{") brace++;
+    else if (ch === "}") brace--;
+    else if (ch === "[") bracket++;
+    else if (ch === "]") bracket--;
+
+    if (ch === ":" && paren === 0 && brace === 0 && bracket === 0) {
+      return [s.slice(0, i).trim(), s.slice(i + 1).trim()];
+    }
+  }
+
+  throw new Error(`expected "key: value", got "${part}"`);
+}