llmz 0.2.0 → 0.2.1

package/dist/chunk-665O7CAN.js

@@ -0,0 +1,788 @@
+import {
+  CodeFormattingError
+} from "./chunk-WSVDMGMR.js";
+import {
+  escapeString,
+  getMultilineComment,
+  toPropertyKey
+} from "./chunk-YX27XM67.js";
+
+// src/typings.ts
+import { z } from "@bpinternal/zui";
+
+// src/typings-formatter.ts
+var WIDTH = 80;
+var INDENT = "  ";
+var isGroup = (n) => n.kind === "group";
+var isPunct = (n, text) => !isGroup(n) && n.kind === "punct" && n.text === text;
+var WORD_CHAR = /[A-Za-z0-9_$.]/;
+function tokenize(src) {
+  const toks = [];
+  let i = 0;
+  let nl = 0;
+  const len = src.length;
+  while (i < len) {
+    const c = src[i];
+    if (c === "\n") {
+      nl++;
+      i++;
+      continue;
+    }
+    if (c === " " || c === "	" || c === "\r") {
+      i++;
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "*") {
+      const end = src.indexOf("*/", i + 2);
+      if (end === -1) {
+        throw new Error("unterminated block comment");
+      }
+      toks.push({ kind: "block-comment", text: src.slice(i, end + 2), nl });
+      nl = 0;
+      i = end + 2;
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "/") {
+      let end = src.indexOf("\n", i);
+      if (end === -1) {
+        end = len;
+      }
+      toks.push({ kind: "line-comment", text: src.slice(i, end).trimEnd(), nl });
+      nl = 0;
+      i = end;
+      continue;
+    }
+    if (c === "'" || c === '"' || c === "`") {
+      let j = i + 1;
+      while (j < len && src[j] !== c) {
+        j += src[j] === "\\" ? 2 : 1;
+      }
+      if (j >= len) {
+        throw new Error("unterminated string");
+      }
+      toks.push({ kind: "string", text: src.slice(i, j + 1), nl });
+      nl = 0;
+      i = j + 1;
+      continue;
+    }
+    if (c === "=" && src[i + 1] === ">") {
+      toks.push({ kind: "punct", text: "=>", nl });
+      nl = 0;
+      i += 2;
+      continue;
+    }
+    if (WORD_CHAR.test(c) || c === "-" && /\d/.test(src[i + 1] ?? "")) {
+      let j = i + 1;
+      while (j < len && WORD_CHAR.test(src[j])) {
+        j++;
+      }
+      toks.push({ kind: "word", text: src.slice(i, j), nl });
+      nl = 0;
+      i = j;
+      continue;
+    }
+    toks.push({ kind: "punct", text: c, nl });
+    nl = 0;
+    i++;
+  }
+  return toks;
+}
+var CLOSER = { "{": "}", "(": ")", "[": "]", "<": ">" };
+function parse(toks) {
+  const root = [];
+  const stack = [];
+  const siblings = () => stack.length ? stack[stack.length - 1].children : root;
+  for (const t of toks) {
+    if (t.kind === "punct" && (t.text === "{" || t.text === "(" || t.text === "[")) {
+      const g = { kind: "group", open: t.text, close: CLOSER[t.text], children: [], nl: t.nl };
+      siblings().push(g);
+      stack.push(g);
+      continue;
+    }
+    if (t.kind === "punct" && t.text === "<") {
+      const prev = siblings()[siblings().length - 1];
+      if (prev && !isGroup(prev) && prev.kind === "word") {
+        const g = { kind: "group", open: "<", close: ">", children: [], nl: t.nl };
+        siblings().push(g);
+        stack.push(g);
+        continue;
+      }
+      siblings().push(t);
+      continue;
+    }
+    if (t.kind === "punct" && (t.text === "}" || t.text === ")" || t.text === "]" || t.text === ">")) {
+      const g = stack[stack.length - 1];
+      if (t.text === ">" && (!g || g.open !== "<")) {
+        siblings().push(t);
+        continue;
+      }
+      if (!g || g.close !== t.text) {
+        throw new Error("unbalanced brackets");
+      }
+      stack.pop();
+      continue;
+    }
+    siblings().push(t);
+  }
+  if (stack.length) {
+    throw new Error("unbalanced brackets");
+  }
+  return root;
+}
+function normalize(nodes) {
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    if (!isGroup(n)) {
+      const key = n.kind === "string" && /^["']([A-Za-z_$][A-Za-z0-9_$]*)["']$/.exec(n.text);
+      const next2 = nodes[i + 1];
+      if (key && next2 && isPunct(next2, ":")) {
+        nodes[i] = { kind: "word", text: key[1], nl: n.nl };
+      }
+      continue;
+    }
+    normalize(n.children);
+    while (n.children.length && (isPunct(n.children[n.children.length - 1], ",") || isPunct(n.children[n.children.length - 1], ";"))) {
+      n.children.pop();
+    }
+    const prev = nodes[i - 1];
+    const next = nodes[i + 1];
+    const wrapsWholeValue = next === void 0 || isPunct(next, ";") || isPunct(next, ",");
+    const isFunctionType = n.children.some((c) => isPunct(c, "=>"));
+    if (n.open === "(" && n.children.length > 0 && prev && isPunct(prev, ":") && wrapsWholeValue && !isFunctionType) {
+      n.children[0].nl = n.nl;
+      nodes.splice(i, 1, ...n.children);
+      i--;
+    }
+  }
+}
+function isMemberEnd(n) {
+  if (isGroup(n)) {
+    return true;
+  }
+  return n.kind === "word" || n.kind === "string" || n.kind === "block-comment" || n.kind === "line-comment" || n.text === "?";
+}
+function isMemberStart(n) {
+  if (isGroup(n)) {
+    return false;
+  }
+  return n.kind === "word" || n.kind === "string" || n.kind === "block-comment" || n.kind === "line-comment";
+}
+function splitMembers(nodes, splitOnComma) {
+  const members = [];
+  let cur = [];
+  let hasSeparators = false;
+  let usedComma = false;
+  const push = () => {
+    if (cur.length) {
+      members.push(cur);
+    }
+    cur = [];
+  };
+  for (const n of nodes) {
+    if (isPunct(n, ";") || splitOnComma && isPunct(n, ",")) {
+      hasSeparators = true;
+      usedComma ||= n.text === ",";
+      push();
+      continue;
+    }
+    const isTrailingLineComment = !isGroup(n) && n.kind === "line-comment" && n.nl === 0;
+    if (isTrailingLineComment && !cur.length && members.length) {
+      members[members.length - 1].push(n);
+      continue;
+    }
+    if (cur.length) {
+      const prev = cur[cur.length - 1];
+      const prevIsLineComment = !isGroup(prev) && prev.kind === "line-comment";
+      if (prevIsLineComment || n.nl > 0 && !isTrailingLineComment && isMemberEnd(prev) && isMemberStart(n)) {
+        push();
+      }
+    }
+    cur.push(n);
+  }
+  push();
+  for (let i = members.length - 2; i >= 0; i--) {
+    const onlyComments = members[i].every((n) => !isGroup(n) && n.kind === "block-comment");
+    if (onlyComments) {
+      members[i + 1].unshift(...members[i]);
+      members.splice(i, 1);
+    }
+  }
+  return { members, hasSeparators, usedComma };
+}
+function hasMultilineComment(nodes) {
+  return nodes.some((n) => !isGroup(n) && n.kind === "block-comment" && n.text.includes("\n"));
+}
+function hasLineComment(nodes) {
+  return nodes.some((n) => !isGroup(n) && n.kind === "line-comment");
+}
+function mustBreak(g) {
+  if (hasLineComment(g.children) || hasMultilineComment(g.children)) {
+    return true;
+  }
+  const { members, hasSeparators } = splitMembers(g.children, true);
+  if (members.length > 1 && !hasSeparators) {
+    return true;
+  }
+  if ((g.open === "{" || g.open === "(") && members.some((m) => !isGroup(m[0]) && m[0].kind === "block-comment")) {
+    return true;
+  }
+  return g.children.some((c) => isGroup(c) && mustBreak(c));
+}
+function needSpace(a, b) {
+  if (!a) {
+    return false;
+  }
+  if (a.kind === "open" && b.kind === "close") {
+    return false;
+  }
+  if (b.kind === "punct" && (b.text === "," || b.text === ";" || b.text === ":" || b.text === "?")) {
+    return false;
+  }
+  if (b.kind === "close") {
+    return b.text === "}";
+  }
+  if (a.kind === "open") {
+    return a.text === "{";
+  }
+  if (b.kind === "open") {
+    if (b.text === "(" || b.text === "[") {
+      return !(a.kind === "word" || a.kind === "string" || a.kind === "close");
+    }
+    if (b.text === "<") {
+      return false;
+    }
+    return true;
+  }
+  return true;
+}
+function flatAtoms(nodes) {
+  const out = [];
+  for (const n of nodes) {
+    if (isGroup(n)) {
+      out.push({ kind: "open", text: n.open });
+      out.push(...flatAtoms(n.children));
+      out.push({ kind: "close", text: n.close });
+    } else {
+      out.push({ kind: n.kind, text: n.text });
+    }
+  }
+  return out;
+}
+function joinAtoms(atoms) {
+  let s = "";
+  let prev = null;
+  for (const a of atoms) {
+    if (needSpace(prev, a)) {
+      s += " ";
+    }
+    s += a.text;
+    prev = a;
+  }
+  return s;
+}
+var canFlatten = (nodes) => !hasLineComment(nodes) && !hasMultilineComment(nodes) && !nodes.some((n) => isGroup(n) && mustBreak(n));
+var Printer = class {
+  _lines = [];
+  _cur = "";
+  _prev = null;
+  atom(a) {
+    if (this._prev && this._cur !== "" && needSpace(this._prev, a)) {
+      this._cur += " ";
+    }
+    this._cur += a.text;
+    this._prev = a;
+  }
+  flat(nodes) {
+    for (const a of flatAtoms(nodes)) {
+      this.atom(a);
+    }
+  }
+  newline(level) {
+    this._lines.push(this._cur);
+    this._cur = INDENT.repeat(level);
+    this._prev = null;
+  }
+  blankLine(level) {
+    this._lines.push(this._cur);
+    this._lines.push("");
+    this._cur = INDENT.repeat(level);
+    this._prev = null;
+  }
+  get column() {
+    return this._cur.length;
+  }
+  get lineIsEmpty() {
+    return this._cur.trim() === "";
+  }
+  comment(text, level) {
+    const lines = text.split("\n").map((l) => l.trim());
+    for (let i = 0; i < lines.length; i++) {
+      if (i > 0) {
+        this.newline(level);
+        this._cur += lines[i].startsWith("*") ? " " : "";
+        this._cur += lines[i];
+      } else {
+        this.atom({ kind: "block-comment", text: lines[i] });
+      }
+      this._prev = { kind: "block-comment", text: lines[i] };
+    }
+  }
+  toString() {
+    this._lines.push(this._cur);
+    const out = this._lines.map((l) => l.trim() === "" ? "" : l).join("\n").replace(/\n{3,}/g, "\n\n");
+    this._lines.pop();
+    return out.trim();
+  }
+};
+function flatWidth(nodes) {
+  if (!canFlatten(nodes)) {
+    return null;
+  }
+  return joinAtoms(flatAtoms(nodes)).length;
+}
+function fitsFlat(p, nodes) {
+  const width = flatWidth(nodes);
+  return width !== null && p.column + width + 1 <= WIDTH;
+}
+function walk(p, nodes, level, tailWidth = 0) {
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    if (isGroup(n)) {
+      const own = mustBreak(n) ? null : flatWidth([n]);
+      let restNodes = nodes.slice(i + 1);
+      const lineCommentIdx = restNodes.findIndex((x) => !isGroup(x) && x.kind === "line-comment");
+      if (lineCommentIdx !== -1) {
+        restNodes = restNodes.slice(0, lineCommentIdx);
+      }
+      const rest = flatWidth(restNodes);
+      const after = rest === null ? 0 : rest + tailWidth;
+      if (own !== null && p.column + 1 + own + after <= WIDTH) {
+        p.flat([n]);
+      } else {
+        breakGroup(p, n, level, after);
+      }
+      continue;
+    }
+    if (n.kind === "block-comment" && n.text.includes("\n")) {
+      if (!p.lineIsEmpty) {
+        p.newline(level);
+      }
+      p.comment(n.text, level);
+      p.newline(level);
+      continue;
+    }
+    if (n.kind === "line-comment") {
+      p.atom({ kind: "line-comment", text: n.text });
+      continue;
+    }
+    p.atom({ kind: n.kind, text: n.text });
+  }
+}
+function breakGroup(p, g, level, tailWidth = 0) {
+  if (g.open === "<") {
+    p.atom({ kind: "open", text: "<" });
+    walk(p, g.children, level, tailWidth + 1);
+    p.atom({ kind: "close", text: ">" });
+    return;
+  }
+  const { members, usedComma } = splitMembers(g.children, true);
+  const hasLeadingComment = members.some((m) => !isGroup(m[0]) && m[0].kind === "block-comment");
+  const single = members.length === 1 ? members[0] : null;
+  const endsInObject = !!single && isGroup(single[single.length - 1]) && single[single.length - 1].open === "{";
+  const hasUnion = !!single && single.some((n) => isPunct(n, "|"));
+  if (g.open === "(" && endsInObject && !hasUnion && !hasLeadingComment) {
+    p.atom({ kind: "open", text: "(" });
+    walk(p, g.children, level, tailWidth + 1);
+    p.atom({ kind: "close", text: ")" });
+    return;
+  }
+  const separator = g.open === "(" || g.open === "[" ? "," : usedComma ? "," : null;
+  const trailingSeparator = g.open === "(" || g.open === "[";
+  p.atom({ kind: "open", text: g.open });
+  for (let i = 0; i < members.length; i++) {
+    p.newline(level + 1);
+    renderMember(p, members[i], level + 1);
+    if (separator && (trailingSeparator || i < members.length - 1)) {
+      p.atom({ kind: "punct", text: separator });
+    }
+  }
+  p.newline(level);
+  p.atom({ kind: "close", text: g.close });
+}
+function renderMember(p, nodes, level) {
+  let rest = nodes;
+  while (rest.length && !isGroup(rest[0]) && rest[0].kind === "block-comment") {
+    const c = rest[0];
+    p.comment(c.text, level);
+    rest = rest.slice(1);
+    if (rest.length) {
+      p.newline(level);
+    }
+  }
+  if (!rest.length) {
+    return;
+  }
+  if (fitsFlat(p, rest)) {
+    p.flat(rest);
+    return;
+  }
+  const pipeIdx = rest.findIndex((n) => isPunct(n, "|"));
+  const parenIdx = rest.findIndex((n) => isGroup(n) && n.open === "(");
+  if (pipeIdx !== -1 && (parenIdx === -1 || pipeIdx < parenIdx)) {
+    let colonIdx = -1;
+    for (let i = 0; i < pipeIdx; i++) {
+      if (isPunct(rest[i], ":") || isPunct(rest[i], "=")) {
+        colonIdx = i;
+      }
+    }
+    const prefix = rest.slice(0, colonIdx + 1);
+    const tail = rest.slice(colonIdx + 1);
+    if (!prefix.length || fitsFlat(p, prefix)) {
+      p.flat(prefix);
+      const options = [];
+      let cur = [];
+      for (const n of tail) {
+        if (isPunct(n, "|")) {
+          options.push(cur);
+          cur = [];
+        } else {
+          cur.push(n);
+        }
+      }
+      options.push(cur);
+      const optionLevel = prefix.length ? level + 1 : level;
+      let first = true;
+      for (const option of options) {
+        if (!option.length) {
+          continue;
+        }
+        if (!first || prefix.length) {
+          p.newline(optionLevel);
+        }
+        first = false;
+        p.atom({ kind: "punct", text: "|" });
+        walk(p, option, optionLevel + 1);
+      }
+      return;
+    }
+  }
+  const eqIdx = rest.findIndex((n) => isPunct(n, "="));
+  if (eqIdx !== -1) {
+    const prefix = rest.slice(0, eqIdx + 1);
+    if (fitsFlat(p, prefix)) {
+      p.flat(prefix);
+      walk(p, rest.slice(eqIdx + 1), level);
+      return;
+    }
+  }
+  walk(p, rest, level);
+}
+function renderStatements(p, nodes, level) {
+  const { members: statements } = splitMembers(nodes, false);
+  for (let i = 0; i < statements.length; i++) {
+    const stmt = statements[i];
+    if (i > 0) {
+      if ((stmt[0].nl ?? 0) >= 2) {
+        p.blankLine(level);
+      } else {
+        p.newline(level);
+      }
+    }
+    renderStatement(p, stmt, level);
+  }
+}
+function renderStatement(p, stmt, level) {
+  while (stmt.length && !isGroup(stmt[0]) && stmt[0].kind === "block-comment") {
+    p.comment(stmt[0].text, level);
+    stmt = stmt.slice(1);
+    if (stmt.length) {
+      p.newline(level);
+    }
+  }
+  if (!stmt.length) {
+    return;
+  }
+  const nsIdx = stmt.findIndex(
+    (n) => !isGroup(n) && n.kind === "word" && (n.text === "namespace" || n.text === "module")
+  );
+  const bodyIdx = stmt.findIndex((n) => isGroup(n) && n.open === "{");
+  if (nsIdx !== -1 && bodyIdx > nsIdx) {
+    const body = stmt[bodyIdx];
+    p.flat(stmt.slice(0, bodyIdx));
+    p.atom({ kind: "open", text: "{" });
+    if (body.children.length) {
+      p.newline(level + 1);
+      renderStatements(p, body.children, level + 1);
+      p.newline(level);
+    }
+    p.atom({ kind: "close", text: "}" });
+    walk(p, stmt.slice(bodyIdx + 1), level);
+    return;
+  }
+  renderMember(p, stmt, level);
+}
+function formatTypingsUnsafe(typings) {
+  const tokens = tokenize(typings);
+  if (!tokens.length) {
+    return "";
+  }
+  const nodes = parse(tokens);
+  normalize(nodes);
+  const printer = new Printer();
+  renderStatements(printer, nodes, 0);
+  return printer.toString();
+}
+
+// src/formatting.ts
+async function formatTypings(typings, options) {
+  try {
+    return formatTypingsUnsafe(typings);
+  } catch (err) {
+    if ((options == null ? void 0 : options.throwOnError) ?? true) {
+      throw new CodeFormattingError(err instanceof Error ? err.message : (err == null ? void 0 : err.toString()) ?? "Unknown Error", typings);
+    }
+    return typings;
+  }
+}
+
+// src/typings.ts
+var Primitives = [
+  "string",
+  "number",
+  "boolean",
+  "unknown",
+  "void",
+  "any",
+  "null",
+  "undefined",
+  "never",
+  "bigint",
+  "symbol",
+  "object"
+];
+var LARGE_DECLARATION_LINES = 5;
+var isPrimitive = (type) => Primitives.includes(type);
+var isArrayOfPrimitives = (type) => Primitives.map((p) => `${p}[]`).includes(type);
+var stripSpaces = (typings) => typings.replace(/ +/g, " ").trim();
+var KeyValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+  }
+};
+var FnParameters = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+};
+var FnReturn = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+};
+var Declaration = class {
+  constructor(schema, identifier) {
+    this.schema = schema;
+    this.identifier = identifier;
+  }
+};
+async function getTypings(schema, options) {
+  options ??= {};
+  options.declaration ??= false;
+  let wrappedSchema = schema;
+  if ((options == null ? void 0 : options.declaration) && z.is.zuiType(schema)) {
+    const title = "title" in schema.ui ? schema.ui.title : null;
+    if (!title) {
+      throw new Error('Only schemas with "title" Zui property can be declared.');
+    }
+    wrappedSchema = new Declaration(schema, title);
+  }
+  let dts = await sUnwrapZodRecursive(wrappedSchema, { ...options });
+  dts = await formatTypings(dts, { throwOnError: false });
+  return dts;
+}
+async function sUnwrapZodRecursive(schema, options) {
+  return sUnwrapZod(schema, options);
+}
+async function sUnwrapZod(schema, options) {
+  var _a, _b;
+  const newOptions = {
+    ...options,
+    declaration: false,
+    parent: schema
+  };
+  if (schema instanceof Declaration) {
+    const description = getMultilineComment(schema.schema.description);
+    const withoutDesc = schema.schema.describe("");
+    const typings = await sUnwrapZodRecursive(withoutDesc, { ...newOptions, declaration: true });
+    const isLargeDeclaration = typings.split("\n").length >= LARGE_DECLARATION_LINES;
+    const closingTag = isLargeDeclaration ? `// end of ${schema.identifier}` : "";
+    if (z.is.zuiFunction(schema.schema)) {
+      return stripSpaces(`${description}
+declare function ${schema.identifier}${typings};${closingTag}`);
+    }
+    return stripSpaces(`${description}
+declare const ${schema.identifier}: ${typings};${closingTag}`);
+  }
+  if (schema instanceof KeyValue) {
+    if (z.is.zuiOptional(schema.value) || z.is.zuiDefault(schema.value)) {
+      let innerType = schema.value._def.innerType;
+      if (z.is.zuiType(innerType) && !innerType.description && schema.value.description) {
+        innerType = innerType == null ? void 0 : innerType.describe(schema.value.description);
+      }
+      const optionalToken = schema.key.endsWith("?") ? "" : "?";
+      return sUnwrapZodRecursive(new KeyValue(schema.key + optionalToken, innerType), newOptions);
+    }
+    const description = getMultilineComment(schema.value._def.description || schema.value.description);
+    const delimiter = (description == null ? void 0 : description.trim().length) > 0 ? "\n" : "";
+    const withoutDesc = schema.value.describe("");
+    return `${delimiter}${description}${delimiter}${schema.key}: ${await sUnwrapZodRecursive(withoutDesc, newOptions)}${delimiter}`;
+  }
+  if (schema instanceof FnParameters) {
+    if (z.is.zuiTuple(schema.schema)) {
+      let args = "";
+      for (let i = 0; i < schema.schema.items.length; i++) {
+        const argName = ((_b = (_a = schema.schema.items[i]) == null ? void 0 : _a.ui) == null ? void 0 : _b.title) ?? `arg${i}`;
+        const item = schema.schema.items[i];
+        args += `${await sUnwrapZodRecursive(new KeyValue(toPropertyKey(argName), item), newOptions)}, `;
+      }
+      return args;
+    }
+    const isLiteral = z.is.zuiLiteral(schema.schema.naked());
+    const typings = (await sUnwrapZodRecursive(schema.schema, newOptions)).trim();
+    const startsWithPairs = typings.startsWith("{") && typings.endsWith("}") || typings.startsWith("[") && typings.endsWith("]") || typings.startsWith("(") && typings.endsWith(")") || typings.startsWith("Array<") && typings.endsWith(">") || typings.startsWith("Record<") && typings.endsWith(">") || isArrayOfPrimitives(typings);
+    if (startsWithPairs || isLiteral) {
+      return `args: ${typings}`;
+    } else {
+      return typings;
+    }
+  }
+  if (schema instanceof FnReturn) {
+    if (z.is.zuiOptional(schema.schema)) {
+      return `${await sUnwrapZodRecursive(schema.schema.unwrap(), newOptions)} | undefined`;
+    }
+    return sUnwrapZodRecursive(schema.schema, newOptions);
+  }
+  if (schema === null) {
+    return "unknown";
+  }
+  schema;
+  if (z.is.zuiDefault(schema)) {
+    return sUnwrapZodRecursive(schema._def.innerType, options);
+  }
+  if (z.is.zuiVoid(schema)) {
+    return "void";
+  }
+  if (z.is.zuiUnknown(schema)) {
+    return "unknown";
+  }
+  if (z.is.zuiAny(schema)) {
+    return "any";
+  }
+  if (z.is.zuiPromise(schema)) {
+    return `Promise<${await sUnwrapZodRecursive(schema.unwrap(), newOptions)}>`;
+  }
+  if (z.is.zuiFunction(schema)) {
+    const description = getMultilineComment(schema._def.description);
+    const input = await sUnwrapZodRecursive(new FnParameters(schema._def.args), newOptions);
+    const output = await sUnwrapZodRecursive(new FnReturn(schema._def.returns), newOptions);
+    if (options == null ? void 0 : options.declaration) {
+      return `${description}
+(${input}): ${output}`;
+    }
+    return `${description}
+(${input}) => ${output}`;
+  }
+  if (z.is.zuiArray(schema)) {
+    const item = await sUnwrapZodRecursive(schema._def.type, newOptions);
+    if (isPrimitive(item)) {
+      return `${item}[]`;
+    }
+    return `Array<${item}>`;
+  }
+  if (z.is.zuiEnum(schema)) {
+    const values = schema._def.values.map(escapeString);
+    return values.join(" | ");
+  }
+  if (z.is.zuiTuple(schema)) {
+    if (schema.items.length === 0) {
+      return "[]";
+    }
+    const items = await Promise.all(schema.items.map((i) => sUnwrapZodRecursive(i, newOptions)));
+    return `[${items.join(", ")}]`;
+  }
+  if (z.is.zuiNullable(schema)) {
+    return `${await sUnwrapZodRecursive(schema.unwrap(), options)} | null`;
+  }
+  if (z.is.zuiOptional(schema)) {
+    if ((options == null ? void 0 : options.declaration) || z.is.zuiType(options == null ? void 0 : options.parent) && options.parent.typeName === "ZodRecord") {
+      return `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)} | undefined`;
+    }
+    const optionalToken = options.parent instanceof KeyValue ? "| undefined" : "";
+    const val = `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)}${optionalToken}`;
+    return val;
+  }
+  if (z.is.zuiObject(schema)) {
+    const props = await Promise.all(
+      Object.entries(schema.shape).map(async ([key, value]) => {
+        if (z.is.zuiType(value)) {
+          return sUnwrapZodRecursive(new KeyValue(toPropertyKey(key), value), newOptions);
+        }
+        return `${key}: unknown`;
+      })
+    );
+    return `{ ${props.join("; ")} }`;
+  }
+  if (z.is.zuiString(schema)) {
+    const description = getMultilineComment(schema._def.description);
+    return `${description} string`.trim();
+  }
+  if (z.is.zuiUnion(schema)) {
+    const description = getMultilineComment(schema._def.description);
+    const options2 = await Promise.all(
+      schema.options.map(async (option) => {
+        return sUnwrapZodRecursive(option, newOptions);
+      })
+    );
+    return `${description}
+${options2.join(" | ")}`;
+  }
+  if (z.is.zuiLiteral(schema)) {
+    const description = getMultilineComment(schema._def.description);
+    return `${description}
+${typeof schema.value === "string" ? escapeString(schema.value) : String(schema.value)}`.trim();
+  }
+  if (z.is.zuiNumber(schema)) {
+    const description = getMultilineComment(schema._def.description);
+    return `${description} number`.trim();
+  }
+  if (z.is.zuiBoolean(schema)) {
+    const description = getMultilineComment(schema._def.description);
+    return `${description} boolean`.trim();
+  }
+  if (z.is.zuiCatch(schema)) {
+    return sUnwrapZodRecursive(schema.removeCatch(), newOptions);
+  }
+  if (z.is.zuiLazy(schema)) {
+    return sUnwrapZodRecursive(schema._def.getter(), newOptions);
+  }
+  if (z.is.zuiRecord(schema)) {
+    const description = getMultilineComment(schema._def.description);
+    const keyType = await sUnwrapZodRecursive(schema._def.keyType, newOptions);
+    const valueType = await sUnwrapZodRecursive(schema._def.valueType, newOptions);
+    return `${description} { [key: (${keyType})]: (${valueType}) }`;
+  }
+  try {
+    let typings = schema == null ? void 0 : schema.toTypescriptType({ treatDefaultAsOptional: true });
+    typings ??= "unknown";
+    return stripSpaces(typings);
+  } catch (error) {
+    console.error("Error in sUnwrapZod", { error, schema, parent: options == null ? void 0 : options.parent });
+    return "unknown";
+  }
+}
+
+export {
+  formatTypings,
+  getTypings
+};