botversion-sdk 2.2.3 → 2.3.1

package/scanner-sdk/scan/nest-source.js

@@ -0,0 +1,918 @@
+// ─────────────────────────────────────────────────────────────
+// FILE: scan/nest-source.js
+// PURPOSE: Reads TypeScript/JavaScript source text for the NestJS scanner: classes and their members, imports across files, constants, and type declarations turned into field schemas.
+// CONTAINS: readSource, setProjectRoot, matchClose, splitTopLevel, findClasses, parseMembers, parseParams, resolveStringExpr, lookupConst, resolveModuleFile, resolveClassByName, typeToSchema, classFieldsSchema
+// USED BY: scan/nestjs.js
+// DEPENDS ON: ./text-utils
+// ─────────────────────────────────────────────────────────────
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const {
+  blankOutComments,
+  skipStaticString,
+  splitStaticEntries,
+} = require("./text-utils");
+
+const sourceCache = new Map();
+let projectRoot = process.cwd();
+let tsPaths = null;
+
+function setProjectRoot(root) {
+  projectRoot = root;
+  tsPaths = null;
+  sourceCache.clear();
+}
+
+// File text with comments blanked out (so commented-out code is never read)
+function readSource(file) {
+  if (sourceCache.has(file)) return sourceCache.get(file);
+  let text = null;
+  try {
+    text = blankOutComments(fs.readFileSync(file, "utf8"));
+  } catch (e) {
+    text = null;
+  }
+  sourceCache.set(file, text);
+  return text;
+}
+
+// Index of the bracket that closes the one at "open" (-1 if it cannot be matched safely)
+function matchClose(text, open) {
+  let depth = 0;
+  for (let i = open; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const e = skipStaticString(text, i, text.length);
+      if (e === -1) return -1;
+      i = e;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") {
+      depth--;
+      if (depth === 0) return i;
+      if (depth < 0) return -1;
+    }
+  }
+  return -1;
+}
+
+// Splits on top-level commas; also keeps generics like Record<string, unknown> together
+function splitTopLevel(text) {
+  const out = [];
+  let cur = "";
+  let depth = 0;
+  let angle = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const e = skipStaticString(text, i, text.length);
+      if (e === -1) return null;
+      cur += text.slice(i, e + 1);
+      i = e;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth--;
+    else if (ch === "<" && depth === 0) angle++;
+    else if (ch === ">" && depth === 0 && text[i - 1] !== "=" && angle > 0)
+      angle--;
+    if (ch === "," && depth === 0 && angle === 0) {
+      out.push(cur.trim());
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  if (cur.trim()) out.push(cur.trim());
+  return out;
+}
+
+// ── Classes ──────────────────────────────────────────────────────────────
+function findClasses(content) {
+  const out = [];
+  const re = /(?:^|[\s;}])class\s+([A-Za-z_$][\w$]*)/g;
+  for (const m of content.matchAll(re)) {
+    const nameIdx = m.index + m[0].length - m[1].length;
+    const kwIdx = content.lastIndexOf("class", nameIdx);
+    let paren = 0;
+    let angle = 0;
+    let open = -1;
+    for (let i = nameIdx + m[1].length; i < content.length; i++) {
+      const ch = content[i];
+      if (ch === '"' || ch === "'" || ch === "`") {
+        const e = skipStaticString(content, i, content.length);
+        if (e === -1) break;
+        i = e;
+        continue;
+      }
+      if (ch === "(") paren++;
+      else if (ch === ")") paren--;
+      else if (ch === "<") angle++;
+      else if (ch === ">" && content[i - 1] !== "=" && angle > 0) angle--;
+      else if (ch === "{" && paren === 0 && angle === 0) {
+        open = i;
+        break;
+      } else if (ch === ";" && paren === 0) break;
+    }
+    if (open === -1) continue;
+    const close = matchClose(content, open);
+    if (close === -1) continue;
+    const header = content.slice(nameIdx + m[1].length, open);
+    const ext = /\bextends\s+([\s\S]+?)(?:\s+implements\b|$)/.exec(header);
+    out.push({
+      name: m[1],
+      kwIdx: kwIdx,
+      open: open,
+      close: close,
+      extendsText: ext ? ext[1].trim() : null,
+    });
+  }
+  return out;
+}
+
+// ── Class members (decorators, methods, properties) ───────────────────────
+const HEAD_RE =
+  /^((?:(?:public|private|protected|static|readonly|abstract|async|override|declare)\s+)*)(\*?\s*)([A-Za-z_$][\w$]*|\[[^\]\n]+\]|'[^'\n]+'|"[^"\n]+")\s*([?!]?)\s*(<[^>(]*>)?\s*(?=[(:=;,}]|\s|$)/;
+
+// Index of the "{" that starts a method body, scanning from the end of its parameter list.
+// Returns { body: index|-1, returnType: text }
+function scanToBody(c, from, limit) {
+  let angle = 0;
+  let paren = 0;
+  let prev = "";
+  for (let i = from; i < limit; i++) {
+    const ch = c[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const e = skipStaticString(c, i, limit);
+      if (e === -1) return { body: -1, end: i };
+      i = e;
+      prev = ch;
+      continue;
+    }
+    if (ch === "(" || ch === "[") paren++;
+    else if (ch === ")" || ch === "]") paren--;
+    else if (ch === "<") angle++;
+    else if (ch === ">" && c[i - 1] !== "=" && angle > 0) angle--;
+    else if (ch === "{") {
+      if (paren === 0 && angle === 0 && !/[:|&<,(]/.test(prev))
+        return { body: i, end: i };
+      const e = matchClose(c, i);
+      if (e === -1) return { body: -1, end: i };
+      i = e;
+      prev = "}";
+      continue;
+    } else if (ch === ";" && paren === 0 && angle === 0)
+      return { body: -1, end: i };
+    if (!/\s/.test(ch)) prev = ch;
+  }
+  return { body: -1, end: limit };
+}
+
+function readDecorators(c, i, limit, list) {
+  while (c[i] === "@") {
+    const dm = /^@([A-Za-z_$][\w$.]*)/.exec(c.slice(i, i + 120));
+    if (!dm) return { pos: i, ok: false };
+    const dec = { name: dm[1], start: i, argsText: "" };
+    let j = i + dm[0].length;
+    if (c[j] === "(") {
+      const e = matchClose(c, j);
+      if (e === -1) return { pos: i, ok: false };
+      dec.argsText = c.slice(j + 1, e);
+      j = e + 1;
+    }
+    dec.end = j;
+    list.push(dec);
+    i = j;
+    while (i < limit && /\s/.test(c[i])) i++;
+  }
+  return { pos: i, ok: true };
+}
+
+function parseMembers(c, open, close) {
+  const members = [];
+  let i = open + 1;
+  while (i < close) {
+    while (i < close && (/\s/.test(c[i]) || c[i] === ";" || c[i] === ",")) i++;
+    if (i >= close) break;
+    const m = { decorators: [], start: i };
+    const dr = readDecorators(c, i, close, m.decorators);
+    if (!dr.ok) break;
+    i = dr.pos;
+    const hm = HEAD_RE.exec(c.slice(i, i + 300));
+    if (!hm) {
+      // unknown syntax: skip to the next ; or line end so one odd member never stops the rest
+      const nl = c.indexOf("\n", i);
+      i = nl === -1 || nl > close ? close : nl + 1;
+      continue;
+    }
+    m.modifiers = hm[1];
+    m.name = hm[3];
+    m.optional = hm[4] === "?";
+    let k = i + hm[0].length;
+    if (c[k] === "(") {
+      const pe = matchClose(c, k);
+      if (pe === -1) break;
+      m.kind = "method";
+      m.paramsText = c.slice(k + 1, pe);
+      const sb = scanToBody(c, pe + 1, close);
+      const rt = c.slice(pe + 1, sb.body === -1 ? sb.end : sb.body).trim();
+      m.returnType = rt.charAt(0) === ":" ? rt.slice(1).trim() : "";
+      if (sb.body !== -1) {
+        const be = matchClose(c, sb.body);
+        if (be === -1) break;
+        m.bodyText = c.slice(sb.body + 1, be);
+        m.end = be + 1;
+      } else {
+        m.bodyText = "";
+        m.end = sb.end + 1;
+      }
+      i = m.end;
+    } else {
+      m.kind = "prop";
+      let depth = 0;
+      let angle = 0;
+      let j = k;
+      let text = "";
+      for (; j < close; j++) {
+        const ch = c[j];
+        if (ch === '"' || ch === "'" || ch === "`") {
+          const e = skipStaticString(c, j, close);
+          if (e === -1) break;
+          text += c.slice(j, e + 1);
+          j = e;
+          continue;
+        }
+        if (ch === "(" || ch === "[" || ch === "{") depth++;
+        else if (ch === ")" || ch === "]" || ch === "}") depth--;
+        else if (ch === "<" && depth === 0) angle++;
+        else if (ch === ">" && depth === 0 && c[j - 1] !== "=" && angle > 0)
+          angle--;
+        if (depth === 0 && angle === 0) {
+          if (ch === ";" || ch === ",") break;
+          if (ch === "\n") {
+            const rest = c.slice(j + 1, close).trimStart();
+            const t = text.trimEnd();
+            if (!/^[|&]/.test(rest) && !/[|&:=<]$/.test(t)) break;
+          }
+        }
+        text += ch;
+      }
+      // split "type = initializer" at the first top-level "="
+      const eq = /(^|[^=!<>])=(?!=|>)/.exec(text);
+      const typePart = eq ? text.slice(0, eq.index + eq[1].length) : text;
+      m.typeText = typePart.replace(/^\s*:\s*/, "").trim() || null;
+      m.end = j + 1;
+      i = m.end;
+    }
+    members.push(m);
+  }
+  return members;
+}
+
+// Parameters of a method: [{ decorators, name, typeText }]
+function parseParams(paramsText) {
+  const entries = splitTopLevel(paramsText) || [];
+  const out = [];
+  entries.forEach(function (entry) {
+    const decorators = [];
+    const dr = readDecorators(entry, 0, entry.length, decorators);
+    if (!dr.ok) return;
+    const rest = entry.slice(dr.pos);
+    const pm =
+      /^(?:(?:public|private|protected|readonly)\s+)*(?:\.\.\.)?([A-Za-z_$][\w$]*)\s*(\?)?\s*(?::\s*([\s\S]+?))?\s*(?:=[\s\S]*)?$/.exec(
+        rest,
+      );
+    out.push({
+      decorators: decorators,
+      name: pm ? pm[1] : null,
+      typeText: pm && pm[3] ? pm[3].trim() : null,
+    });
+  });
+  return out;
+}
+
+// ── Imports and files ─────────────────────────────────────────────────────
+function loadTsPaths() {
+  if (tsPaths) return tsPaths;
+  tsPaths = { baseUrl: null, paths: {} };
+  try {
+    let raw = fs.readFileSync(path.join(projectRoot, "tsconfig.json"), "utf8");
+    raw = blankOutComments(raw).replace(/,(\s*[}\]])/g, "$1");
+    const co = JSON.parse(raw).compilerOptions || {};
+    if (co.baseUrl) tsPaths.baseUrl = path.resolve(projectRoot, co.baseUrl);
+    tsPaths.paths = co.paths || {};
+  } catch (e) {}
+  return tsPaths;
+}
+
+function tryFile(base) {
+  const stripped = base.replace(/\.(js|mjs|cjs)$/, "");
+  const tries = [
+    base,
+    base + ".ts",
+    base + ".tsx",
+    base + ".js",
+    stripped + ".ts",
+    path.join(base, "index.ts"),
+    path.join(base, "index.js"),
+  ];
+  for (const t of tries) {
+    try {
+      if (fs.statSync(t).isFile()) return t;
+    } catch (e) {}
+  }
+  return null;
+}
+
+// Turns an import path into a file inside the project (null for packages and anything unreadable)
+function resolveModuleFile(fromFile, spec) {
+  if (/^\.{1,2}([\\/]|$)/.test(spec))
+    return tryFile(path.resolve(path.dirname(fromFile), spec));
+  const tp = loadTsPaths();
+  for (const pattern of Object.keys(tp.paths)) {
+    const star = pattern.indexOf("*");
+    const matches =
+      star === -1
+        ? spec === pattern
+        : spec.startsWith(pattern.slice(0, star)) &&
+          spec.endsWith(pattern.slice(star + 1));
+    if (!matches) continue;
+    const mid =
+      star === -1
+        ? ""
+        : spec.slice(star, spec.length - (pattern.length - star - 1));
+    for (const target of tp.paths[pattern]) {
+      const f = tryFile(
+        path.resolve(tp.baseUrl || projectRoot, target.replace("*", mid)),
+      );
+      if (f) return f;
+    }
+  }
+  if (tp.baseUrl) return tryFile(path.resolve(tp.baseUrl, spec));
+  return null;
+}
+
+// local name -> { spec, imported } for every import in a file
+function parseImports(content) {
+  const out = {};
+  for (const m of content.matchAll(
+    /import\s+(?:type\s+)?([\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g,
+  )) {
+    const clause = m[1].trim();
+    const named = /\{([\s\S]*)\}/.exec(clause);
+    if (named) {
+      named[1].split(",").forEach(function (p) {
+        const parts = p
+          .trim()
+          .replace(/^type\s+/, "")
+          .split(/\s+as\s+/);
+        if (parts[0])
+          out[(parts[1] || parts[0]).trim()] = {
+            spec: m[2],
+            imported: parts[0].trim(),
+          };
+      });
+    }
+    const def = /^([A-Za-z_$][\w$]*)\s*(?:,|$)/.exec(clause);
+    if (def) out[def[1]] = { spec: m[2], imported: "default" };
+  }
+  for (const m of content.matchAll(
+    /(?:const|let|var)\s+\{([^}]+)\}\s*=\s*require\(\s*['"]([^'"]+)['"]\s*\)/g,
+  )) {
+    m[1].split(",").forEach(function (p) {
+      const parts = p.trim().split(/\s*:\s*/);
+      if (parts[0])
+        out[(parts[1] || parts[0]).trim()] = {
+          spec: m[2],
+          imported: parts[0].trim(),
+        };
+    });
+  }
+  return out;
+}
+
+// Follows "export * from" / "export { X } from" in barrel files
+function reExportTargets(content, file) {
+  const out = [];
+  for (const m of content.matchAll(
+    /export\s+(?:\*|\{[^}]*\})\s+from\s+['"]([^'"]+)['"]/g,
+  )) {
+    const f = resolveModuleFile(file, m[1]);
+    if (f) out.push(f);
+  }
+  return out;
+}
+
+// Finds where a name is declared: this file first, then through its imports and barrel re-exports
+function findDeclaration(name, file, depth, seen) {
+  seen = seen || new Set();
+  const key = file + "::" + name;
+  if (depth > 5 || seen.has(key)) return null;
+  seen.add(key);
+  const c = readSource(file);
+  if (!c) return null;
+  const safe = name.replace(/\$/g, "\\$");
+
+  const cls = findClasses(c).find(function (k) {
+    return k.name === name;
+  });
+  if (cls) return { kind: "class", file: file, cls: cls };
+
+  let m = new RegExp("(?:^|[\\s;}])interface\\s+" + safe + "\\b[^{]*\\{").exec(
+    c,
+  );
+  if (m) {
+    const open = m.index + m[0].length - 1;
+    const close = matchClose(c, open);
+    const ext = /\bextends\s+([^{]+)$/.exec(m[0].slice(0, -1));
+    if (close !== -1)
+      return {
+        kind: "interface",
+        file: file,
+        open: open,
+        close: close,
+        extendsText: ext ? ext[1].trim() : null,
+      };
+  }
+  m = new RegExp(
+    "(?:^|[\\s;}])type\\s+" + safe + "\\b\\s*(?:<[^=]*>)?\\s*=\\s*",
+  ).exec(c);
+  if (m) {
+    const start = m.index + m[0].length;
+    const e = readExpression(c, start);
+    return { kind: "type", file: file, expr: c.slice(start, e).trim() };
+  }
+  m = new RegExp("(?:^|[\\s;}])enum\\s+" + safe + "\\s*\\{").exec(c);
+  if (m) {
+    const open = m.index + m[0].length - 1;
+    const close = matchClose(c, open);
+    if (close !== -1)
+      return { kind: "enum", file: file, body: c.slice(open + 1, close) };
+  }
+  // imported or re-exported
+  const imp = parseImports(c)[name];
+  if (imp) {
+    const f = resolveModuleFile(file, imp.spec);
+    if (f) {
+      const found = findDeclaration(
+        imp.imported === "default" ? name : imp.imported,
+        f,
+        depth + 1,
+        seen,
+      );
+      if (found) return found;
+    }
+  }
+  for (const f of reExportTargets(c, file)) {
+    const found = findDeclaration(name, f, depth + 1, seen);
+    if (found) return found;
+  }
+  return null;
+}
+
+// End index of an expression that starts at "start" (a ";" or line end outside any brackets)
+function readExpression(c, start) {
+  let depth = 0;
+  let angle = 0;
+  for (let i = start; i < c.length; i++) {
+    const ch = c[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const e = skipStaticString(c, i, c.length);
+      if (e === -1) return c.length;
+      i = e;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") {
+      depth--;
+      if (depth < 0) return i;
+    } else if (ch === "<" && depth === 0) angle++;
+    else if (ch === ">" && depth === 0 && c[i - 1] !== "=" && angle > 0)
+      angle--;
+    if (depth === 0 && angle === 0) {
+      if (ch === ";") return i;
+      if (ch === "\n") {
+        const rest = c.slice(i + 1).trimStart();
+        const t = c.slice(start, i).trimEnd();
+        if (!/^[|&+.?:]/.test(rest) && !/[|&+:=<,]$/.test(t)) return i;
+      }
+    }
+  }
+  return c.length;
+}
+
+// ── Constants ─────────────────────────────────────────────────────────────
+// Finds "const NAME = <expr>" in a file or through its imports: { expr, file } or null
+function lookupConst(name, file, depth) {
+  depth = depth || 0;
+  if (depth > 5) return null;
+  const c = readSource(file);
+  if (!c) return null;
+  const safe = name.replace(/\$/g, "\\$");
+  const m = new RegExp(
+    "(?:^|[\\s;}])(?:const|let|var)\\s+" + safe + "\\s*(?::[^=]+)?=\\s*",
+  ).exec(c);
+  if (m) {
+    const start = m.index + m[0].length;
+    return {
+      expr: c.slice(start, readExpression(c, start)).trim(),
+      file: file,
+    };
+  }
+  const imp = parseImports(c)[name];
+  if (imp) {
+    const f = resolveModuleFile(file, imp.spec);
+    if (f)
+      return lookupConst(
+        imp.imported === "default" ? name : imp.imported,
+        f,
+        depth + 1,
+      );
+  }
+  for (const f of reExportTargets(c, file)) {
+    const found = lookupConst(name, f, depth + 1);
+    if (found) return found;
+  }
+  return null;
+}
+
+// Reads a text value written as a literal, a template, a constant, OBJ.KEY, or pieces joined with "+".
+// Returns null when any piece cannot be known.
+function resolveStringExpr(expr, file, depth) {
+  depth = depth || 0;
+  if (depth > 6 || expr === undefined || expr === null) return null;
+  let e = String(expr)
+    .trim()
+    .replace(/\s+as\s+const$/, "");
+  if (!e) return null;
+  const plus = splitOnPlus(e);
+  if (plus.length > 1) {
+    let out = "";
+    for (const p of plus) {
+      const v = resolveStringExpr(p, file, depth + 1);
+      if (v === null) return null;
+      out += v;
+    }
+    return out;
+  }
+  if (/^\(([\s\S]*)\)$/.test(e))
+    return resolveStringExpr(e.slice(1, -1), file, depth + 1);
+  let q = /^(['"])([\s\S]*)\1$/.exec(e);
+  if (q) return q[2];
+  q = /^`([\s\S]*)`$/.exec(e);
+  if (q) {
+    let bad = false;
+    const out = q[1].replace(/\$\{\s*([^}]+?)\s*\}/g, function (all, inner) {
+      const v = resolveStringExpr(inner, file, depth + 1);
+      if (v === null) bad = true;
+      return v === null ? "" : v;
+    });
+    return bad ? null : out;
+  }
+  if (/^[A-Za-z_$][\w$]*$/.test(e)) {
+    const found = lookupConst(e, file);
+    if (found) return resolveStringExpr(found.expr, found.file, depth + 1);
+    const en = findDeclaration(e, file, 0);
+    return en && en.kind === "enum" ? null : null;
+  }
+  const mm = /^([A-Za-z_$][\w$]*)\s*\.\s*([A-Za-z_$][\w$]*)$/.exec(e);
+  if (mm) return resolveMember(mm[1], mm[2], file, depth + 1);
+  return null;
+}
+
+function splitOnPlus(e) {
+  const parts = [];
+  let cur = "";
+  let depth = 0;
+  for (let i = 0; i < e.length; i++) {
+    const ch = e[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const end = skipStaticString(e, i, e.length);
+      if (end === -1) return [e];
+      cur += e.slice(i, end + 1);
+      i = end;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth--;
+    if (ch === "+" && depth === 0) {
+      parts.push(cur.trim());
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  parts.push(cur.trim());
+  return parts.length > 1 && parts.every(Boolean) ? parts : [e];
+}
+
+// OBJ.KEY where OBJ is a constant object or an enum
+function resolveMember(objName, key, file, depth) {
+  const found = lookupConst(objName, file);
+  if (found) {
+    const obj = found.expr.replace(/\s+as\s+const$/, "").trim();
+    if (obj.charAt(0) === "{") {
+      const inner = obj.slice(
+        1,
+        matchClose(obj, 0) === -1 ? obj.length : matchClose(obj, 0),
+      );
+      for (const entry of splitStaticEntries(inner) || []) {
+        const km =
+          /^(?:"([^"]+)"|'([^']+)'|([A-Za-z_$][\w$]*))\s*:\s*([\s\S]+)$/.exec(
+            entry,
+          );
+        if (km && (km[1] || km[2] || km[3]) === key)
+          return resolveStringExpr(km[4], found.file, depth + 1);
+      }
+    }
+    return null;
+  }
+  const decl = findDeclaration(objName, file, 0);
+  if (decl && decl.kind === "enum") {
+    for (const entry of splitStaticEntries(decl.body) || []) {
+      const em = /^([A-Za-z_$][\w$]*)\s*(?:=\s*([\s\S]+))?$/.exec(entry);
+      if (em && em[1] === key && em[2])
+        return resolveStringExpr(em[2], decl.file, depth + 1);
+    }
+  }
+  return null;
+}
+
+// ── Types -> field schemas ────────────────────────────────────────────────
+const PRIMITIVES = {
+  string: "string",
+  number: "number",
+  boolean: "boolean",
+  bigint: "number",
+  integer: "number",
+};
+const BINARY_TYPES =
+  /^(?:Express\.Multer\.File|MulterFile|File|Blob|Buffer|Readable|Stream)$/;
+
+function splitUnion(t) {
+  const parts = [];
+  let cur = "";
+  let depth = 0;
+  for (let i = 0; i < t.length; i++) {
+    const ch = t[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const e = skipStaticString(t, i, t.length);
+      if (e === -1) return [t];
+      cur += t.slice(i, e + 1);
+      i = e;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{" || ch === "<") depth++;
+    else if (
+      ch === ")" ||
+      ch === "]" ||
+      ch === "}" ||
+      (ch === ">" && t[i - 1] !== "=")
+    )
+      depth--;
+    if (ch === "|" && depth === 0) {
+      parts.push(cur.trim());
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  parts.push(cur.trim());
+  return parts.filter(Boolean);
+}
+
+function objectSchema(properties) {
+  return { type: "object", properties: properties };
+}
+
+function membersToProperties(c, open, close, file, depth, seen) {
+  const props = {};
+  parseMembers(c, open, close).forEach(function (mem) {
+    if (
+      mem.kind !== "prop" ||
+      /\b(static|private|protected)\b/.test(mem.modifiers || "")
+    )
+      return;
+    const s = typeToSchema(mem.typeText || "any", file, depth + 1, seen);
+    if (s) props[mem.name.replace(/^['"]|['"]$/g, "")] = s;
+  });
+  return props;
+}
+
+// Fields of a class including everything it inherits (extends Base, PartialType(Base), OmitType(...), ...)
+function classProperties(decl, depth, seen) {
+  const c = readSource(decl.file);
+  const props = {};
+  const cls = decl.cls;
+  if (cls.extendsText)
+    Object.assign(
+      props,
+      inheritedProperties(cls.extendsText, decl.file, depth, seen),
+    );
+  Object.assign(
+    props,
+    membersToProperties(c, cls.open, cls.close, decl.file, depth, seen),
+  );
+  return props;
+}
+
+function inheritedProperties(extendsText, file, depth, seen) {
+  const call = /^([A-Za-z_$][\w$.]*)\s*\(([\s\S]*)\)\s*$/.exec(extendsText);
+  if (call) {
+    const fn = call[1].split(".").pop();
+    const args = splitTopLevel(call[2]) || [];
+    const fromArg = function (a) {
+      const d = /^[A-Za-z_$][\w$]*$/.test(a)
+        ? findDeclaration(a, file, 0)
+        : null;
+      return d && d.kind === "class" ? classProperties(d, depth, seen) : {};
+    };
+    if (fn === "PartialType" || fn === "RequiredType")
+      return fromArg(args[0] || "");
+    if (fn === "IntersectionType")
+      return Object.assign({}, fromArg(args[0] || ""), fromArg(args[1] || ""));
+    if (fn === "OmitType" || fn === "PickType") {
+      const base = fromArg(args[0] || "");
+      const keys = ((args[1] || "").match(/['"`]([^'"`]+)['"`]/g) || []).map(
+        function (k) {
+          return k.slice(1, -1);
+        },
+      );
+      const out = {};
+      Object.keys(base).forEach(function (k) {
+        if (fn === "OmitType" ? keys.indexOf(k) === -1 : keys.indexOf(k) !== -1)
+          out[k] = base[k];
+      });
+      return out;
+    }
+    return {};
+  }
+  const name = extendsText.replace(/<[\s\S]*$/, "").trim();
+  if (!/^[A-Za-z_$][\w$]*$/.test(name)) return {};
+  const d = findDeclaration(name, file, 0);
+  if (d && d.kind === "class") return classProperties(d, depth, seen);
+  if (d && d.kind === "interface") return interfaceProperties(d, depth, seen);
+  return {};
+}
+
+function interfaceProperties(decl, depth, seen) {
+  const c = readSource(decl.file);
+  const props = decl.extendsText
+    ? Object.assign(
+        {},
+        inheritedFromList(decl.extendsText, decl.file, depth, seen),
+      )
+    : {};
+  return Object.assign(
+    props,
+    membersToProperties(c, decl.open, decl.close, decl.file, depth, seen),
+  );
+}
+
+function inheritedFromList(text, file, depth, seen) {
+  let out = {};
+  (splitTopLevel(text) || []).forEach(function (n) {
+    out = Object.assign(out, inheritedProperties(n, file, depth, seen));
+  });
+  return out;
+}
+
+// Turns a TypeScript type written in code into a schema. Returns null for "no value" types.
+function typeToSchema(typeText, file, depth, seen) {
+  depth = depth || 0;
+  seen = seen || new Set();
+  if (typeText === undefined || typeText === null) return null;
+  let t = String(typeText)
+    .trim()
+    .replace(/^readonly\s+/, "");
+  if (!t || depth > 8) return { type: "unknown" }; // nesting limit; cycles are stopped separately
+  if (/^\(([\s\S]*)\)$/.test(t) && matchClose(t, 0) === t.length - 1)
+    t = t.slice(1, -1).trim();
+
+  const union = splitUnion(t);
+  if (union.length > 1) {
+    const real = union.filter(function (u) {
+      return u !== "null" && u !== "undefined";
+    });
+    if (real.length === 0) return null;
+    if (real.length === 1) return typeToSchema(real[0], file, depth + 1, seen);
+    const lits = real.map(function (u) {
+      return /^(['"`])([\s\S]*)\1$/.exec(u);
+    });
+    if (lits.every(Boolean))
+      return {
+        type: "string",
+        enum: lits.map(function (l) {
+          return l[2];
+        }),
+      };
+    if (
+      real.every(function (u) {
+        return /^-?\d+(\.\d+)?$/.test(u);
+      })
+    )
+      return { type: "number", enum: real.map(Number) };
+    return typeToSchema(real[0], file, depth + 1, seen);
+  }
+  if (/\[\]$/.test(t))
+    return {
+      type: "array",
+      items: typeToSchema(t.slice(0, -2), file, depth + 1, seen) || {
+        type: "unknown",
+      },
+    };
+  let m = /^(?:Array|ReadonlyArray|Set)\s*<([\s\S]+)>$/.exec(t);
+  if (m)
+    return {
+      type: "array",
+      items: typeToSchema(m[1], file, depth + 1, seen) || { type: "unknown" },
+    };
+  m = /^(?:Promise|Partial|Required|Readonly)\s*<([\s\S]+)>$/.exec(t);
+  if (m) return typeToSchema(m[1], file, depth + 1, seen);
+  if (/^(?:Record|Map)\s*</.test(t) || t === "object" || t === "Object")
+    return { type: "object" };
+  m = /^(Omit|Pick)\s*<\s*([A-Za-z_$][\w$]*)\s*,([\s\S]+)>$/.exec(t);
+  if (m) {
+    const base = typeToSchema(m[2], file, depth + 1, seen);
+    const keys = (m[3].match(/['"`]([^'"`]+)['"`]/g) || []).map(function (k) {
+      return k.slice(1, -1);
+    });
+    if (!base || !base.properties) return { type: "object" };
+    const out = {};
+    Object.keys(base.properties).forEach(function (k) {
+      if (m[1] === "Omit" ? keys.indexOf(k) === -1 : keys.indexOf(k) !== -1)
+        out[k] = base.properties[k];
+    });
+    return objectSchema(out);
+  }
+  m = /^(['"`])([\s\S]*)\1$/.exec(t);
+  if (m) return { type: "string", enum: [m[2]] };
+  if (/^-?\d+(\.\d+)?$/.test(t)) return { type: "number" };
+  if (t === "true" || t === "false") return { type: "boolean" };
+  if (PRIMITIVES[t]) return { type: PRIMITIVES[t] };
+  if (t === "Date") return { type: "string", format: "date-time" };
+  if (t === "void" || t === "undefined" || t === "null" || t === "never")
+    return null;
+  if (t === "any" || t === "unknown") return { type: "unknown" };
+  if (BINARY_TYPES.test(t)) return { type: "string", format: "binary" };
+  if (t.charAt(0) === "{" && matchClose(t, 0) === t.length - 1) {
+    return objectSchema(
+      membersToProperties(t, 0, t.length - 1, file, depth, seen),
+    );
+  }
+  const name = t.replace(/<[\s\S]*$/, "").trim();
+  if (!/^[A-Za-z_$][\w$]*$/.test(name)) return { type: "unknown" };
+  const decl = findDeclaration(name, file, 0);
+  if (!decl) return { type: "unknown" };
+  const key = decl.file + "::" + name;
+  if (seen.has(key)) return { type: "object" };
+  const nextSeen = new Set(seen);
+  nextSeen.add(key);
+  if (decl.kind === "class")
+    return objectSchema(classProperties(decl, depth + 1, nextSeen));
+  if (decl.kind === "interface")
+    return objectSchema(interfaceProperties(decl, depth + 1, nextSeen));
+  if (decl.kind === "type")
+    return typeToSchema(decl.expr, decl.file, depth + 1, nextSeen);
+  if (decl.kind === "enum") {
+    const values = [];
+    let numeric = true;
+    (splitStaticEntries(decl.body) || []).forEach(function (en) {
+      const em = /^([A-Za-z_$][\w$]*)\s*(?:=\s*([\s\S]+))?$/.exec(en);
+      if (!em) return;
+      const lit = em[2] ? /^(['"`])([\s\S]*)\1$/.exec(em[2].trim()) : null;
+      if (lit) {
+        numeric = false;
+        values.push(lit[2]);
+      }
+    });
+    return numeric ? { type: "number" } : { type: "string", enum: values };
+  }
+  return { type: "unknown" };
+}
+
+// Finds a class by name from a given file (same file or imported)
+function resolveClassByName(name, file) {
+  const d = findDeclaration(name, file, 0);
+  return d && d.kind === "class" ? d : null;
+}
+
+module.exports = {
+  readSource,
+  setProjectRoot,
+  matchClose,
+  splitTopLevel,
+  findClasses,
+  parseMembers,
+  parseParams,
+  parseImports,
+  resolveStringExpr,
+  lookupConst,
+  resolveModuleFile,
+  resolveClassByName,
+  typeToSchema,
+  inheritedProperties,
+};