@formspec/build 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/internals.cjs

@@ -0,0 +1,1345 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/internals.ts
+var internals_exports = {};
+__export(internals_exports, {
+  analyzeClass: () => analyzeClass,
+  analyzeInterface: () => analyzeInterface,
+  analyzeTypeAlias: () => analyzeTypeAlias,
+  collectFormSpecReferences: () => collectFormSpecReferences,
+  createProgramContext: () => createProgramContext,
+  findClassByName: () => findClassByName,
+  findInterfaceByName: () => findInterfaceByName,
+  findTypeAliasByName: () => findTypeAliasByName,
+  generateClassSchemas: () => generateClassSchemas,
+  generateMethodSchemas: () => generateMethodSchemas,
+  generateUiSchemaFromFields: () => generateUiSchemaFromFields
+});
+module.exports = __toCommonJS(internals_exports);
+
+// src/analyzer/program.ts
+var ts = __toESM(require("typescript"), 1);
+var path = __toESM(require("path"), 1);
+function createProgramContext(filePath) {
+  const absolutePath = path.resolve(filePath);
+  const fileDir = path.dirname(absolutePath);
+  const configPath = ts.findConfigFile(fileDir, ts.sys.fileExists.bind(ts.sys), "tsconfig.json");
+  let compilerOptions;
+  let fileNames;
+  if (configPath) {
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile.bind(ts.sys));
+    if (configFile.error) {
+      throw new Error(
+        `Error reading tsconfig.json: ${ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`
+      );
+    }
+    const parsed = ts.parseJsonConfigFileContent(
+      configFile.config,
+      ts.sys,
+      path.dirname(configPath)
+    );
+    if (parsed.errors.length > 0) {
+      const errorMessages = parsed.errors.map((e) => ts.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
+      throw new Error(`Error parsing tsconfig.json: ${errorMessages}`);
+    }
+    compilerOptions = parsed.options;
+    fileNames = parsed.fileNames.includes(absolutePath) ? parsed.fileNames : [...parsed.fileNames, absolutePath];
+  } else {
+    compilerOptions = {
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.NodeNext,
+      moduleResolution: ts.ModuleResolutionKind.NodeNext,
+      strict: true,
+      skipLibCheck: true,
+      declaration: true
+    };
+    fileNames = [absolutePath];
+  }
+  const program = ts.createProgram(fileNames, compilerOptions);
+  const sourceFile = program.getSourceFile(absolutePath);
+  if (!sourceFile) {
+    throw new Error(`Could not find source file: ${absolutePath}`);
+  }
+  return {
+    program,
+    checker: program.getTypeChecker(),
+    sourceFile
+  };
+}
+function findNodeByName(sourceFile, name, predicate, getName) {
+  let result = null;
+  function visit(node) {
+    if (result) return;
+    if (predicate(node) && getName(node) === name) {
+      result = node;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function findClassByName(sourceFile, className) {
+  return findNodeByName(sourceFile, className, ts.isClassDeclaration, (n) => n.name?.text);
+}
+function findInterfaceByName(sourceFile, interfaceName) {
+  return findNodeByName(sourceFile, interfaceName, ts.isInterfaceDeclaration, (n) => n.name.text);
+}
+function findTypeAliasByName(sourceFile, aliasName) {
+  return findNodeByName(sourceFile, aliasName, ts.isTypeAliasDeclaration, (n) => n.name.text);
+}
+
+// src/analyzer/class-analyzer.ts
+var ts4 = __toESM(require("typescript"), 1);
+
+// src/analyzer/decorator-extractor.ts
+var ts2 = __toESM(require("typescript"), 1);
+var import_core = require("@formspec/core");
+function extractDecorators(member) {
+  const decorators = [];
+  const modifiers = ts2.canHaveDecorators(member) ? ts2.getDecorators(member) : void 0;
+  if (!modifiers) return decorators;
+  for (const decorator of modifiers) {
+    const info = parseDecorator(decorator);
+    if (info) {
+      decorators.push(info);
+    }
+  }
+  return decorators;
+}
+function parseDecorator(decorator) {
+  const expr = decorator.expression;
+  if (ts2.isIdentifier(expr)) {
+    return {
+      name: expr.text,
+      args: [],
+      node: decorator
+    };
+  }
+  if (ts2.isCallExpression(expr)) {
+    const callee = expr.expression;
+    let name = null;
+    if (ts2.isIdentifier(callee)) {
+      name = callee.text;
+    } else if (ts2.isPropertyAccessExpression(callee)) {
+      name = callee.name.text;
+    }
+    if (!name) return null;
+    const args = expr.arguments.map(extractArgValue);
+    return {
+      name,
+      args,
+      node: decorator
+    };
+  }
+  return null;
+}
+function extractArgValue(node) {
+  if (ts2.isStringLiteral(node)) {
+    return node.text;
+  }
+  if (ts2.isNumericLiteral(node)) {
+    return Number(node.text);
+  }
+  if (node.kind === ts2.SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (node.kind === ts2.SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  if (node.kind === ts2.SyntaxKind.NullKeyword) {
+    return null;
+  }
+  if (ts2.isPrefixUnaryExpression(node)) {
+    if (node.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(node.operand)) {
+      return -Number(node.operand.text);
+    }
+    if (node.operator === ts2.SyntaxKind.PlusToken && ts2.isNumericLiteral(node.operand)) {
+      return Number(node.operand.text);
+    }
+  }
+  if (ts2.isArrayLiteralExpression(node)) {
+    return node.elements.map((el) => {
+      if (ts2.isSpreadElement(el)) {
+        return null;
+      }
+      return extractArgValue(el);
+    });
+  }
+  if (ts2.isObjectLiteralExpression(node)) {
+    const obj = {};
+    for (const prop of node.properties) {
+      if (ts2.isPropertyAssignment(prop)) {
+        const key = getPropertyName(prop.name);
+        if (key) {
+          obj[key] = extractArgValue(prop.initializer);
+        }
+      } else if (ts2.isShorthandPropertyAssignment(prop)) {
+        const key = prop.name.text;
+        obj[key] = null;
+      }
+    }
+    return obj;
+  }
+  if (ts2.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text;
+  }
+  if (ts2.isRegularExpressionLiteral(node)) {
+    const regexText = node.text;
+    const lastSlash = regexText.lastIndexOf("/");
+    if (lastSlash > 0) {
+      return regexText.substring(1, lastSlash);
+    }
+    return regexText;
+  }
+  if (ts2.isNewExpression(node)) {
+    if (ts2.isIdentifier(node.expression) && node.expression.text === "RegExp" && node.arguments && node.arguments.length > 0) {
+      const firstArg = node.arguments[0];
+      if (firstArg && ts2.isStringLiteral(firstArg)) {
+        return firstArg.text;
+      }
+    }
+  }
+  if (ts2.isIdentifier(node)) {
+    return null;
+  }
+  return null;
+}
+function getPropertyName(name) {
+  if (ts2.isIdentifier(name)) {
+    return name.text;
+  }
+  if (ts2.isStringLiteral(name)) {
+    return name.text;
+  }
+  if (ts2.isNumericLiteral(name)) {
+    return name.text;
+  }
+  return null;
+}
+var FORMSPEC_DECORATORS = {
+  // Display metadata
+  Field: { argTypes: ["object"] },
+  // Grouping
+  Group: { argTypes: ["string"] },
+  // Conditional display
+  ShowWhen: { argTypes: ["object"] },
+  // Enum options
+  EnumOptions: { argTypes: ["array"] },
+  // Numeric constraints
+  Minimum: { argTypes: ["number"] },
+  Maximum: { argTypes: ["number"] },
+  ExclusiveMinimum: { argTypes: ["number"] },
+  ExclusiveMaximum: { argTypes: ["number"] },
+  // String constraints
+  MinLength: { argTypes: ["number"] },
+  MaxLength: { argTypes: ["number"] },
+  Pattern: { argTypes: ["string"] }
+};
+function isFormSpecDecoratorsPath(fileName) {
+  const normalized = fileName.replace(/\\/g, "/");
+  return normalized.includes("node_modules/@formspec/decorators") || normalized.includes("/packages/decorators/");
+}
+function resolveDecorator(decorator, checker) {
+  const expr = decorator.expression;
+  let targetNode;
+  let name;
+  if (ts2.isIdentifier(expr)) {
+    targetNode = expr;
+    name = expr.text;
+  } else if (ts2.isCallExpression(expr)) {
+    if (ts2.isIdentifier(expr.expression)) {
+      targetNode = expr.expression;
+      name = expr.expression.text;
+    } else {
+      return null;
+    }
+  } else {
+    return null;
+  }
+  if (name in FORMSPEC_DECORATORS) {
+    const symbol = checker.getSymbolAtLocation(targetNode);
+    if (symbol) {
+      const declarations = symbol.declarations;
+      if (declarations && declarations.length > 0) {
+        const decl = declarations[0];
+        if (decl) {
+          const sourceFile = decl.getSourceFile();
+          const fileName = sourceFile.fileName;
+          if (isFormSpecDecoratorsPath(fileName)) {
+            return {
+              name,
+              isFormSpec: true,
+              isMarker: !ts2.isCallExpression(expr)
+            };
+          }
+        }
+      }
+    }
+  }
+  const resolvedSymbol = checker.getSymbolAtLocation(targetNode);
+  if (!resolvedSymbol) return null;
+  const type = checker.getTypeOfSymbol(resolvedSymbol);
+  const props = type.getProperties();
+  let extendsBuiltin;
+  let extensionName;
+  let isMarker = false;
+  for (const prop of props) {
+    const escapedName = prop.getEscapedName();
+    if (escapedName.startsWith("__@") && (escapedName.includes("formspec.extends") || escapedName.includes("FORMSPEC_EXTENDS"))) {
+      const propType = checker.getTypeOfSymbol(prop);
+      if (propType.isStringLiteral()) {
+        extendsBuiltin = propType.value;
+      }
+    }
+    if (escapedName.startsWith("__@") && (escapedName.includes("formspec.extension") || escapedName.includes("FORMSPEC_EXTENSION"))) {
+      const propType = checker.getTypeOfSymbol(prop);
+      if (propType.isStringLiteral()) {
+        extensionName = propType.value;
+      }
+    }
+    if (escapedName.startsWith("__@") && (escapedName.includes("formspec.marker") || escapedName.includes("FORMSPEC_MARKER"))) {
+      isMarker = true;
+    }
+  }
+  if (extendsBuiltin) {
+    return {
+      name,
+      extendsBuiltin,
+      isFormSpec: true,
+      isMarker: false
+    };
+  }
+  if (extensionName) {
+    return {
+      name,
+      extensionName,
+      isFormSpec: true,
+      isMarker
+    };
+  }
+  if (isMarker) {
+    return {
+      name,
+      isFormSpec: true,
+      isMarker: true
+    };
+  }
+  return null;
+}
+
+// src/analyzer/jsdoc-constraints.ts
+var ts3 = __toESM(require("typescript"), 1);
+var import_core2 = require("@formspec/core");
+function extractJSDocConstraints(node) {
+  const results = [];
+  const jsDocTags = ts3.getJSDocTags(node);
+  for (const tag of jsDocTags) {
+    const tagName = tag.tagName.text;
+    if (!(tagName in import_core2.CONSTRAINT_TAG_DEFINITIONS)) {
+      continue;
+    }
+    const constraintName = tagName;
+    const expectedType = import_core2.CONSTRAINT_TAG_DEFINITIONS[constraintName];
+    const commentText = getTagCommentText(tag);
+    if (commentText === void 0 || commentText === "") {
+      continue;
+    }
+    const trimmed = commentText.trim();
+    if (trimmed === "") {
+      continue;
+    }
+    if (expectedType === "number") {
+      const value = Number(trimmed);
+      if (Number.isNaN(value)) {
+        continue;
+      }
+      results.push(createSyntheticDecorator(constraintName, value));
+    } else if (expectedType === "json") {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed)) {
+          continue;
+        }
+        results.push(createSyntheticDecorator(constraintName, parsed));
+      } catch {
+        continue;
+      }
+    } else {
+      results.push(createSyntheticDecorator(constraintName, trimmed));
+    }
+  }
+  return results;
+}
+function extractJSDocFieldMetadata(node) {
+  const jsDocTags = ts3.getJSDocTags(node);
+  let displayName;
+  let description;
+  for (const tag of jsDocTags) {
+    const tagName = tag.tagName.text;
+    const commentText = getTagCommentText(tag);
+    if (commentText === void 0 || commentText.trim() === "") {
+      continue;
+    }
+    const trimmed = commentText.trim();
+    if (tagName === "Field_displayName") {
+      displayName = trimmed;
+    } else if (tagName === "Field_description") {
+      description = trimmed;
+    }
+  }
+  if (displayName === void 0 && description === void 0) {
+    return null;
+  }
+  const fieldOpts = {
+    ...displayName !== void 0 ? { displayName } : {},
+    ...description !== void 0 ? { description } : {}
+  };
+  return createSyntheticDecorator("Field", fieldOpts);
+}
+function getTagCommentText(tag) {
+  if (tag.comment === void 0) {
+    return void 0;
+  }
+  if (typeof tag.comment === "string") {
+    return tag.comment;
+  }
+  return ts3.getTextOfJSDocComment(tag.comment);
+}
+function createSyntheticDecorator(name, value) {
+  return {
+    name,
+    args: [value],
+    node: void 0
+  };
+}
+
+// src/analyzer/class-analyzer.ts
+function analyzeClass(classDecl, checker) {
+  const name = classDecl.name?.text ?? "AnonymousClass";
+  const fields = [];
+  const instanceMethods = [];
+  const staticMethods = [];
+  for (const member of classDecl.members) {
+    if (ts4.isPropertyDeclaration(member)) {
+      const fieldInfo = analyzeField(member, checker);
+      if (fieldInfo) {
+        fields.push(fieldInfo);
+      }
+    } else if (ts4.isMethodDeclaration(member)) {
+      const methodInfo = analyzeMethod(member, checker);
+      if (methodInfo) {
+        const isStatic = member.modifiers?.some((m) => m.kind === ts4.SyntaxKind.StaticKeyword);
+        if (isStatic) {
+          staticMethods.push(methodInfo);
+        } else {
+          instanceMethods.push(methodInfo);
+        }
+      }
+    }
+  }
+  return {
+    name,
+    fields,
+    instanceMethods,
+    staticMethods
+  };
+}
+function analyzeField(prop, checker) {
+  if (!ts4.isIdentifier(prop.name)) {
+    return null;
+  }
+  const name = prop.name.text;
+  const typeNode = prop.type;
+  const type = checker.getTypeAtLocation(prop);
+  const optional = prop.questionToken !== void 0;
+  const decorators = extractDecorators(prop);
+  for (const dec of decorators) {
+    if (dec.node) {
+      const resolved = resolveDecorator(dec.node, checker);
+      if (resolved) {
+        dec.resolved = resolved;
+      }
+    }
+  }
+  if (prop.type) {
+    const aliasConstraints = extractTypeAliasConstraints(prop.type, checker);
+    decorators.push(...aliasConstraints);
+  }
+  const jsdocConstraints = extractJSDocConstraints(prop);
+  decorators.push(...jsdocConstraints);
+  const deprecated = hasDeprecatedTag(prop);
+  const defaultValue = extractDefaultValue(prop.initializer);
+  return {
+    name,
+    typeNode,
+    type,
+    optional,
+    decorators,
+    deprecated,
+    defaultValue
+  };
+}
+function extractTypeAliasConstraints(typeNode, checker) {
+  if (!ts4.isTypeReferenceNode(typeNode)) return [];
+  const symbol = checker.getSymbolAtLocation(typeNode.typeName);
+  if (!symbol?.declarations) return [];
+  const aliasDecl = symbol.declarations.find(ts4.isTypeAliasDeclaration);
+  if (!aliasDecl) return [];
+  if (ts4.isTypeLiteralNode(aliasDecl.type)) return [];
+  return extractJSDocConstraints(aliasDecl);
+}
+function hasDeprecatedTag(node) {
+  const jsDocTags = ts4.getJSDocTags(node);
+  return jsDocTags.some((tag) => tag.tagName.text === "deprecated");
+}
+function extractDefaultValue(initializer) {
+  if (!initializer) return void 0;
+  if (ts4.isStringLiteral(initializer)) {
+    return initializer.text;
+  }
+  if (ts4.isNumericLiteral(initializer)) {
+    return Number(initializer.text);
+  }
+  if (initializer.kind === ts4.SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (initializer.kind === ts4.SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  if (initializer.kind === ts4.SyntaxKind.NullKeyword) {
+    return null;
+  }
+  if (ts4.isPrefixUnaryExpression(initializer)) {
+    if (initializer.operator === ts4.SyntaxKind.MinusToken && ts4.isNumericLiteral(initializer.operand)) {
+      return -Number(initializer.operand.text);
+    }
+  }
+  return void 0;
+}
+function analyzeMethod(method, checker) {
+  if (!ts4.isIdentifier(method.name)) {
+    return null;
+  }
+  const name = method.name.text;
+  const parameters = [];
+  for (const param of method.parameters) {
+    if (ts4.isIdentifier(param.name)) {
+      const paramInfo = analyzeParameter(param, checker);
+      parameters.push(paramInfo);
+    }
+  }
+  const returnTypeNode = method.type;
+  const signature = checker.getSignatureFromDeclaration(method);
+  const returnType = signature ? checker.getReturnTypeOfSignature(signature) : checker.getTypeAtLocation(method);
+  return {
+    name,
+    parameters,
+    returnTypeNode,
+    returnType
+  };
+}
+function analyzeParameter(param, checker) {
+  const name = ts4.isIdentifier(param.name) ? param.name.text : "param";
+  const typeNode = param.type;
+  const type = checker.getTypeAtLocation(param);
+  const formSpecExportName = detectFormSpecReference(typeNode);
+  const optional = param.questionToken !== void 0 || param.initializer !== void 0;
+  return {
+    name,
+    typeNode,
+    type,
+    formSpecExportName,
+    optional
+  };
+}
+function detectFormSpecReference(typeNode) {
+  if (!typeNode) return null;
+  if (!ts4.isTypeReferenceNode(typeNode)) return null;
+  const typeName = ts4.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : ts4.isQualifiedName(typeNode.typeName) ? typeNode.typeName.right.text : null;
+  if (typeName !== "InferSchema" && typeName !== "InferFormSchema") return null;
+  const typeArg = typeNode.typeArguments?.[0];
+  if (!typeArg || !ts4.isTypeQueryNode(typeArg)) return null;
+  if (ts4.isIdentifier(typeArg.exprName)) {
+    return typeArg.exprName.text;
+  }
+  if (ts4.isQualifiedName(typeArg.exprName)) {
+    return typeArg.exprName.right.text;
+  }
+  return null;
+}
+function analyzeInterface(interfaceDecl, checker) {
+  const name = interfaceDecl.name.text;
+  const fields = [];
+  for (const member of interfaceDecl.members) {
+    if (ts4.isPropertySignature(member)) {
+      const fieldInfo = analyzeInterfaceProperty(member, checker);
+      if (fieldInfo) {
+        fields.push(fieldInfo);
+      }
+    }
+  }
+  return {
+    name,
+    fields,
+    instanceMethods: [],
+    staticMethods: []
+  };
+}
+function analyzeTypeAlias(typeAlias, checker) {
+  if (!ts4.isTypeLiteralNode(typeAlias.type)) {
+    const sourceFile = typeAlias.getSourceFile();
+    const { line } = sourceFile.getLineAndCharacterOfPosition(typeAlias.getStart());
+    const kindDesc = ts4.SyntaxKind[typeAlias.type.kind] ?? "unknown";
+    return {
+      ok: false,
+      error: `Type alias "${typeAlias.name.text}" at line ${String(line + 1)} is not an object type literal (found ${kindDesc})`
+    };
+  }
+  const name = typeAlias.name.text;
+  const fields = [];
+  for (const member of typeAlias.type.members) {
+    if (ts4.isPropertySignature(member)) {
+      const fieldInfo = analyzeInterfaceProperty(member, checker);
+      if (fieldInfo) {
+        fields.push(fieldInfo);
+      }
+    }
+  }
+  return {
+    ok: true,
+    analysis: {
+      name,
+      fields,
+      instanceMethods: [],
+      staticMethods: []
+    }
+  };
+}
+function analyzeInterfaceProperty(prop, checker) {
+  if (!ts4.isIdentifier(prop.name)) {
+    return null;
+  }
+  const name = prop.name.text;
+  const typeNode = prop.type;
+  const type = checker.getTypeAtLocation(prop);
+  const optional = prop.questionToken !== void 0;
+  const decorators = [];
+  if (typeNode) {
+    const aliasConstraints = extractTypeAliasConstraints(typeNode, checker);
+    decorators.push(...aliasConstraints);
+  }
+  const fieldMetadata = extractJSDocFieldMetadata(prop);
+  if (fieldMetadata) {
+    decorators.push(fieldMetadata);
+  }
+  const jsdocConstraints = extractJSDocConstraints(prop);
+  decorators.push(...jsdocConstraints);
+  const deprecated = hasDeprecatedTag(prop);
+  return {
+    name,
+    typeNode,
+    type,
+    optional,
+    decorators,
+    deprecated,
+    defaultValue: void 0
+  };
+}
+
+// src/analyzer/type-converter.ts
+var ts5 = __toESM(require("typescript"), 1);
+
+// src/json-schema/types.ts
+function setSchemaExtension(schema, key, value) {
+  schema[key] = value;
+}
+
+// src/analyzer/type-converter.ts
+function getNamedTypeFieldInfoMap(type, checker) {
+  const symbols = [type.getSymbol(), type.aliasSymbol].filter(
+    (s) => s?.declarations != null && s.declarations.length > 0
+  );
+  for (const symbol of symbols) {
+    const declarations = symbol.declarations;
+    if (!declarations) continue;
+    const classDecl = declarations.find(ts5.isClassDeclaration);
+    if (classDecl) {
+      const map = /* @__PURE__ */ new Map();
+      for (const member of classDecl.members) {
+        if (ts5.isPropertyDeclaration(member) && ts5.isIdentifier(member.name)) {
+          const fieldInfo = analyzeField(member, checker);
+          if (fieldInfo) map.set(fieldInfo.name, fieldInfo);
+        }
+      }
+      return map;
+    }
+    const interfaceDecl = declarations.find(ts5.isInterfaceDeclaration);
+    if (interfaceDecl) {
+      return buildFieldInfoMapFromSignatures(interfaceDecl.members, checker);
+    }
+    const typeAliasDecl = declarations.find(ts5.isTypeAliasDeclaration);
+    if (typeAliasDecl && ts5.isTypeLiteralNode(typeAliasDecl.type)) {
+      return buildFieldInfoMapFromSignatures(typeAliasDecl.type.members, checker);
+    }
+  }
+  return null;
+}
+function buildFieldInfoMapFromSignatures(members, checker) {
+  const map = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    if (ts5.isPropertySignature(member)) {
+      const fieldInfo = analyzeInterfaceProperty(member, checker);
+      if (fieldInfo) {
+        map.set(fieldInfo.name, fieldInfo);
+      }
+    }
+  }
+  return map;
+}
+function getObjectPropertyInfos(type, checker) {
+  const fieldInfoMap = getNamedTypeFieldInfoMap(type, checker);
+  const result = [];
+  for (const prop of type.getProperties()) {
+    const declaration = prop.valueDeclaration ?? prop.declarations?.[0];
+    if (!declaration) continue;
+    const propType = checker.getTypeOfSymbolAtLocation(prop, declaration);
+    const optional = !!(prop.flags & ts5.SymbolFlags.Optional);
+    const fieldInfo = fieldInfoMap?.get(prop.name) ?? void 0;
+    result.push({ name: prop.name, type: propType, optional, fieldInfo });
+  }
+  return result;
+}
+function convertType(type, checker) {
+  return convertTypeInternal(type, checker, /* @__PURE__ */ new Set());
+}
+function convertTypeInternal(type, checker, visiting) {
+  if (type.flags & ts5.TypeFlags.String) {
+    return { jsonSchema: { type: "string" }, formSpecFieldType: "text" };
+  }
+  if (type.flags & ts5.TypeFlags.Number) {
+    return { jsonSchema: { type: "number" }, formSpecFieldType: "number" };
+  }
+  if (type.flags & ts5.TypeFlags.Boolean) {
+    return { jsonSchema: { type: "boolean" }, formSpecFieldType: "boolean" };
+  }
+  if (type.flags & ts5.TypeFlags.Null) {
+    return { jsonSchema: { type: "null" }, formSpecFieldType: "null" };
+  }
+  if (type.flags & ts5.TypeFlags.Undefined) {
+    return { jsonSchema: {}, formSpecFieldType: "undefined" };
+  }
+  if (type.isStringLiteral()) {
+    return {
+      jsonSchema: { const: type.value },
+      formSpecFieldType: "enum"
+    };
+  }
+  if (type.isNumberLiteral()) {
+    return {
+      jsonSchema: { const: type.value },
+      formSpecFieldType: "number"
+    };
+  }
+  if (type.isUnion()) {
+    return convertUnionType(type, checker, visiting);
+  }
+  if (checker.isArrayType(type)) {
+    return convertArrayType(type, checker, visiting);
+  }
+  if (type.flags & ts5.TypeFlags.Object) {
+    return convertObjectType(type, checker, visiting);
+  }
+  return { jsonSchema: {}, formSpecFieldType: "unknown" };
+}
+function convertUnionType(type, checker, visiting) {
+  const types = type.types;
+  const nonNullTypes = types.filter(
+    (t) => !(t.flags & (ts5.TypeFlags.Null | ts5.TypeFlags.Undefined))
+  );
+  const hasNull = types.some((t) => t.flags & ts5.TypeFlags.Null);
+  const isBooleanUnion = nonNullTypes.length === 2 && nonNullTypes.every((t) => t.flags & ts5.TypeFlags.BooleanLiteral);
+  if (isBooleanUnion) {
+    const result = {
+      jsonSchema: { type: "boolean" },
+      formSpecFieldType: "boolean"
+    };
+    if (hasNull) {
+      result.jsonSchema = { oneOf: [{ type: "boolean" }, { type: "null" }] };
+    }
+    return result;
+  }
+  const allStringLiterals = nonNullTypes.every((t) => t.isStringLiteral());
+  if (allStringLiterals && nonNullTypes.length > 0) {
+    const enumValues = nonNullTypes.map((t) => t.value);
+    const result = {
+      jsonSchema: { enum: enumValues },
+      formSpecFieldType: "enum"
+    };
+    if (hasNull) {
+      result.jsonSchema = { oneOf: [{ enum: enumValues }, { type: "null" }] };
+    }
+    return result;
+  }
+  const allNumberLiterals = nonNullTypes.every((t) => t.isNumberLiteral());
+  if (allNumberLiterals && nonNullTypes.length > 0) {
+    const enumValues = nonNullTypes.map((t) => t.value);
+    const result = {
+      jsonSchema: { enum: enumValues },
+      formSpecFieldType: "enum"
+    };
+    if (hasNull) {
+      result.jsonSchema = { oneOf: [{ enum: enumValues }, { type: "null" }] };
+    }
+    return result;
+  }
+  if (nonNullTypes.length === 1 && nonNullTypes[0]) {
+    const result = convertTypeInternal(nonNullTypes[0], checker, visiting);
+    if (hasNull) {
+      result.jsonSchema = { oneOf: [result.jsonSchema, { type: "null" }] };
+    }
+    return result;
+  }
+  const schemas = nonNullTypes.map((t) => convertTypeInternal(t, checker, visiting).jsonSchema);
+  if (hasNull) {
+    schemas.push({ type: "null" });
+  }
+  return {
+    jsonSchema: { oneOf: schemas },
+    formSpecFieldType: "union"
+  };
+}
+function convertArrayType(type, checker, visiting) {
+  const typeArgs = type.typeArguments;
+  const elementType = typeArgs?.[0];
+  const itemSchema = elementType ? convertTypeInternal(elementType, checker, visiting).jsonSchema : {};
+  return {
+    jsonSchema: {
+      type: "array",
+      items: itemSchema
+    },
+    formSpecFieldType: "array"
+  };
+}
+function convertObjectType(type, checker, visiting) {
+  if (visiting.has(type)) {
+    return { jsonSchema: { type: "object" }, formSpecFieldType: "object" };
+  }
+  visiting.add(type);
+  const properties = {};
+  const required = [];
+  for (const propInfo of getObjectPropertyInfos(type, checker)) {
+    const propSchema = convertTypeInternal(propInfo.type, checker, visiting).jsonSchema;
+    properties[propInfo.name] = propInfo.fieldInfo ? applyDecoratorsToSchema(propSchema, propInfo.fieldInfo.decorators, propInfo.fieldInfo) : propSchema;
+    if (!propInfo.optional) {
+      required.push(propInfo.name);
+    }
+  }
+  visiting.delete(type);
+  return {
+    jsonSchema: {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {}
+    },
+    formSpecFieldType: "object"
+  };
+}
+function createFormSpecField(fieldName, type, decorators, optional, checker, visitedTypes = /* @__PURE__ */ new Set()) {
+  const { formSpecFieldType } = convertType(type, checker);
+  const field = {
+    _field: formSpecFieldType,
+    id: fieldName
+  };
+  if (!optional) {
+    field.required = true;
+  }
+  if (formSpecFieldType === "object" && type.flags & ts5.TypeFlags.Object) {
+    if (!visitedTypes.has(type)) {
+      visitedTypes.add(type);
+      const nestedFields = [];
+      for (const propInfo of getObjectPropertyInfos(type, checker)) {
+        nestedFields.push(
+          createFormSpecField(
+            propInfo.name,
+            propInfo.type,
+            propInfo.fieldInfo?.decorators ?? [],
+            propInfo.optional,
+            checker,
+            visitedTypes
+          )
+        );
+      }
+      visitedTypes.delete(type);
+      if (nestedFields.length > 0) {
+        field.fields = nestedFields;
+      }
+    }
+  }
+  for (const dec of decorators) {
+    applyDecoratorToField(field, dec);
+  }
+  return field;
+}
+function applyDecoratorToField(field, decorator) {
+  const { args } = decorator;
+  const resolved = decorator.resolved;
+  const effectiveName = resolved?.extendsBuiltin ?? decorator.name;
+  switch (effectiveName) {
+    case "Field": {
+      const opts = args[0];
+      if (typeof opts === "object" && opts !== null && !Array.isArray(opts)) {
+        if (typeof opts["displayName"] === "string") {
+          field.label = opts["displayName"];
+        }
+        if (typeof opts["description"] === "string") {
+          field.description = opts["description"];
+        }
+        if (typeof opts["placeholder"] === "string") {
+          field.placeholder = opts["placeholder"];
+        }
+      }
+      break;
+    }
+    case "Minimum":
+      if (typeof args[0] === "number") {
+        field.min = args[0];
+      }
+      break;
+    case "Maximum":
+      if (typeof args[0] === "number") {
+        field.max = args[0];
+      }
+      break;
+    case "MinLength":
+      if (typeof args[0] === "number") {
+        field.minLength = args[0];
+      }
+      break;
+    case "MaxLength":
+      if (typeof args[0] === "number") {
+        field.maxLength = args[0];
+      }
+      break;
+    case "Pattern":
+      if (typeof args[0] === "string") {
+        field.pattern = args[0];
+      }
+      break;
+    case "EnumOptions":
+      if (Array.isArray(args[0])) {
+        field.options = args[0];
+      }
+      break;
+    case "ShowWhen":
+      if (typeof args[0] === "object" && args[0] !== null) {
+        field.showWhen = args[0];
+      }
+      break;
+    case "Group":
+      if (typeof args[0] === "string") {
+        field.group = args[0];
+      }
+      break;
+  }
+}
+function applyDecoratorsToSchema(schema, decorators, fieldInfo) {
+  const result = { ...schema };
+  for (const dec of decorators) {
+    const { args } = dec;
+    const resolved = dec.resolved;
+    const effectiveName = resolved?.extendsBuiltin ?? dec.name;
+    switch (effectiveName) {
+      case "Field": {
+        const opts = args[0];
+        if (typeof opts === "object" && opts !== null && !Array.isArray(opts)) {
+          if (typeof opts["displayName"] === "string") {
+            result.title = opts["displayName"];
+          }
+          if (typeof opts["description"] === "string") {
+            result.description = opts["description"];
+          }
+        }
+        break;
+      }
+      case "Minimum":
+        if (typeof args[0] === "number") {
+          result.minimum = args[0];
+        }
+        break;
+      case "Maximum":
+        if (typeof args[0] === "number") {
+          result.maximum = args[0];
+        }
+        break;
+      case "ExclusiveMinimum":
+        if (typeof args[0] === "number") {
+          result.exclusiveMinimum = args[0];
+        }
+        break;
+      case "ExclusiveMaximum":
+        if (typeof args[0] === "number") {
+          result.exclusiveMaximum = args[0];
+        }
+        break;
+      case "MinLength":
+        if (typeof args[0] === "number") {
+          result.minLength = args[0];
+        }
+        break;
+      case "MaxLength":
+        if (typeof args[0] === "number") {
+          result.maxLength = args[0];
+        }
+        break;
+      case "Pattern":
+        if (typeof args[0] === "string") {
+          result.pattern = args[0];
+        }
+        break;
+    }
+    if (resolved?.extensionName && /^[a-z][a-z0-9-]*$/.test(resolved.extensionName)) {
+      const key = `x-formspec-${resolved.extensionName}`;
+      if (resolved.isMarker) {
+        setSchemaExtension(result, key, true);
+      } else {
+        setSchemaExtension(result, key, args[0] ?? true);
+      }
+    }
+  }
+  if (fieldInfo) {
+    if (fieldInfo.deprecated) {
+      result.deprecated = true;
+    }
+    if (fieldInfo.defaultValue !== void 0) {
+      result.default = fieldInfo.defaultValue;
+    }
+  }
+  return result;
+}
+
+// src/ui-schema/schema.ts
+var import_zod = require("zod");
+var jsonPointerSchema = import_zod.z.string();
+var ruleEffectSchema = import_zod.z.enum(["SHOW", "HIDE", "ENABLE", "DISABLE"]);
+var uiSchemaElementTypeSchema = import_zod.z.enum([
+  "Control",
+  "VerticalLayout",
+  "HorizontalLayout",
+  "Group",
+  "Categorization",
+  "Category",
+  "Label"
+]);
+var ruleConditionSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    const: import_zod.z.unknown().optional(),
+    enum: import_zod.z.array(import_zod.z.unknown()).readonly().optional(),
+    type: import_zod.z.string().optional(),
+    not: ruleConditionSchema.optional(),
+    minimum: import_zod.z.number().optional(),
+    maximum: import_zod.z.number().optional(),
+    exclusiveMinimum: import_zod.z.number().optional(),
+    exclusiveMaximum: import_zod.z.number().optional(),
+    minLength: import_zod.z.number().optional(),
+    properties: import_zod.z.record(import_zod.z.string(), ruleConditionSchema).optional(),
+    required: import_zod.z.array(import_zod.z.string()).optional(),
+    allOf: import_zod.z.array(ruleConditionSchema).optional()
+  }).strict()
+);
+var schemaBasedConditionSchema = import_zod.z.object({
+  scope: jsonPointerSchema,
+  schema: ruleConditionSchema
+}).strict();
+var ruleSchema = import_zod.z.object({
+  effect: ruleEffectSchema,
+  condition: schemaBasedConditionSchema
+}).strict();
+var uiSchemaElementSchema = import_zod.z.lazy(
+  () => import_zod.z.union([
+    controlSchema,
+    verticalLayoutSchema,
+    horizontalLayoutSchema,
+    groupLayoutSchema,
+    categorizationSchema,
+    categorySchema,
+    labelElementSchema
+  ])
+);
+var controlSchema = import_zod.z.object({
+  type: import_zod.z.literal("Control"),
+  scope: jsonPointerSchema,
+  label: import_zod.z.union([import_zod.z.string(), import_zod.z.literal(false)]).optional(),
+  rule: ruleSchema.optional(),
+  options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+}).passthrough();
+var verticalLayoutSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("VerticalLayout"),
+    elements: import_zod.z.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+  }).passthrough()
+);
+var horizontalLayoutSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("HorizontalLayout"),
+    elements: import_zod.z.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+  }).passthrough()
+);
+var groupLayoutSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("Group"),
+    label: import_zod.z.string(),
+    elements: import_zod.z.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+  }).passthrough()
+);
+var categorySchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("Category"),
+    label: import_zod.z.string(),
+    elements: import_zod.z.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+  }).passthrough()
+);
+var categorizationSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("Categorization"),
+    elements: import_zod.z.array(categorySchema),
+    label: import_zod.z.string().optional(),
+    rule: ruleSchema.optional(),
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+  }).passthrough()
+);
+var labelElementSchema = import_zod.z.object({
+  type: import_zod.z.literal("Label"),
+  text: import_zod.z.string(),
+  rule: ruleSchema.optional(),
+  options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+}).passthrough();
+var uiSchema = import_zod.z.lazy(
+  () => import_zod.z.union([verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorizationSchema])
+);
+
+// src/ui-schema/generator.ts
+var import_zod2 = require("zod");
+function parseOrThrow(schema, value, label) {
+  try {
+    return schema.parse(value);
+  } catch (error) {
+    if (error instanceof import_zod2.z.ZodError) {
+      throw new Error(
+        `Generated ${label} failed validation:
+${error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
+      );
+    }
+    throw error;
+  }
+}
+function formSpecFieldToElement(field, scopePrefix = "#/properties") {
+  const control = {
+    type: "Control",
+    scope: `${scopePrefix}/${field.id}`
+  };
+  if (field.label !== void 0) {
+    control.label = field.label;
+  }
+  if (field.showWhen !== void 0 && typeof field.showWhen === "object" && "field" in field.showWhen && "value" in field.showWhen) {
+    const sw = field.showWhen;
+    control.rule = {
+      effect: "SHOW",
+      condition: {
+        scope: `#/properties/${sw.field}`,
+        schema: { const: sw.value }
+      }
+    };
+  }
+  return control;
+}
+function generateUiSchemaFromFields(fields) {
+  const groupMap = /* @__PURE__ */ new Map();
+  const orderedKeys = [];
+  const ungrouped = [];
+  for (const field of fields) {
+    const element = formSpecFieldToElement(field);
+    if (field.group !== void 0) {
+      if (!groupMap.has(field.group)) {
+        groupMap.set(field.group, []);
+        orderedKeys.push(field.group);
+      }
+      groupMap.get(field.group).push(element);
+    } else {
+      orderedKeys.push(null);
+      ungrouped.push(element);
+    }
+  }
+  const elements = [];
+  let ungroupedIndex = 0;
+  for (const key of orderedKeys) {
+    if (key === null) {
+      const el = ungrouped[ungroupedIndex++];
+      if (el !== void 0) {
+        elements.push(el);
+      }
+    } else {
+      const groupElements = groupMap.get(key) ?? [];
+      const groupLayout = {
+        type: "Group",
+        label: key,
+        elements: groupElements
+      };
+      elements.push(groupLayout);
+    }
+  }
+  const result = {
+    type: "VerticalLayout",
+    elements
+  };
+  return parseOrThrow(uiSchema, result, "UI Schema");
+}
+
+// src/generators/class-schema.ts
+function generateClassSchemas(analysis, checker) {
+  const properties = {};
+  const required = [];
+  const uiElements = [];
+  for (const field of analysis.fields) {
+    const { jsonSchema: baseSchema } = convertType(field.type, checker);
+    const fieldSchema = applyDecoratorsToSchema(baseSchema, field.decorators, field);
+    properties[field.name] = fieldSchema;
+    if (!field.optional) {
+      required.push(field.name);
+    }
+    const formSpecField = createFormSpecField(
+      field.name,
+      field.type,
+      field.decorators,
+      field.optional,
+      checker
+    );
+    uiElements.push(formSpecField);
+  }
+  const jsonSchema = {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+  const uiSchema2 = generateUiSchemaFromFields(uiElements);
+  return { jsonSchema, uiSchema: uiSchema2 };
+}
+
+// src/generators/method-schema.ts
+function generateMethodSchemas(method, checker, loadedFormSpecs) {
+  const returnType = convertType(method.returnType, checker).jsonSchema;
+  const params = generateParamsSchemas(method.parameters, checker, loadedFormSpecs);
+  return {
+    name: method.name,
+    params,
+    returnType
+  };
+}
+function generateParamsSchemas(parameters, checker, loadedFormSpecs) {
+  if (parameters.length === 0) {
+    return null;
+  }
+  for (const param of parameters) {
+    if (param.formSpecExportName) {
+      const formSpec = loadedFormSpecs.get(param.formSpecExportName);
+      if (formSpec) {
+        return {
+          jsonSchema: formSpec.jsonSchema,
+          uiSchema: formSpec.uiSchema,
+          formSpecExport: param.formSpecExportName
+        };
+      }
+      console.warn(
+        `Warning: FormSpec export "${param.formSpecExportName}" not found, using static analysis`
+      );
+    }
+  }
+  if (parameters.length === 1 && parameters[0]) {
+    const param = parameters[0];
+    const jsonSchema = convertType(param.type, checker).jsonSchema;
+    return {
+      jsonSchema,
+      uiSchema: null,
+      formSpecExport: null
+    };
+  }
+  const properties = {};
+  const required = [];
+  for (const param of parameters) {
+    const paramSchema = convertType(param.type, checker).jsonSchema;
+    properties[param.name] = paramSchema;
+    if (!param.optional) {
+      required.push(param.name);
+    }
+  }
+  return {
+    jsonSchema: {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {}
+    },
+    uiSchema: null,
+    formSpecExport: null
+  };
+}
+function collectFormSpecReferences(methods) {
+  const references = /* @__PURE__ */ new Set();
+  for (const method of methods) {
+    for (const param of method.parameters) {
+      if (param.formSpecExportName) {
+        references.add(param.formSpecExportName);
+      }
+    }
+  }
+  return references;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzeClass,
+  analyzeInterface,
+  analyzeTypeAlias,
+  collectFormSpecReferences,
+  createProgramContext,
+  findClassByName,
+  findInterfaceByName,
+  findTypeAliasByName,
+  generateClassSchemas,
+  generateMethodSchemas,
+  generateUiSchemaFromFields
+});
+//# sourceMappingURL=internals.cjs.map