@formspec/build 0.1.0-alpha.24 → 0.1.0-alpha.27

package/dist/internals.cjs

@@ -32,12 +32,14 @@ var internals_exports = {};
 __export(internals_exports, {
   analyzeClassToIR: () => analyzeClassToIR,
   analyzeInterfaceToIR: () => analyzeInterfaceToIR,
+  analyzeNamedTypeToIRFromProgramContext: () => analyzeNamedTypeToIRFromProgramContext,
   analyzeTypeAliasToIR: () => analyzeTypeAliasToIR,
   canonicalizeChainDSL: () => canonicalizeChainDSL,
   canonicalizeTSDoc: () => canonicalizeTSDoc,
   collectFormSpecReferences: () => collectFormSpecReferences,
   createExtensionRegistry: () => createExtensionRegistry,
   createProgramContext: () => createProgramContext,
+  createProgramContextFromProgram: () => createProgramContextFromProgram,
   findClassByName: () => findClassByName,
   findInterfaceByName: () => findInterfaceByName,
   findTypeAliasByName: () => findTypeAliasByName,
@@ -2393,6 +2395,18 @@ function detectFormSpecReference(typeNode) {
 }
 
 // src/analyzer/program.ts
+function createProgramContextFromProgram(program, filePath) {
+  const absolutePath = path.resolve(filePath);
+  const sourceFile = program.getSourceFile(absolutePath) ?? program.getSourceFile(filePath);
+  if (!sourceFile) {
+    throw new Error(`Could not find source file in provided program: ${absolutePath}`);
+  }
+  return {
+    program,
+    checker: program.getTypeChecker(),
+    sourceFile
+  };
+}
 function createProgramContext(filePath) {
   const absolutePath = path.resolve(filePath);
   const fileDir = path.dirname(absolutePath);
@@ -2461,6 +2475,36 @@ function findInterfaceByName(sourceFile, interfaceName) {
 function findTypeAliasByName(sourceFile, aliasName) {
   return findNodeByName(sourceFile, aliasName, ts4.isTypeAliasDeclaration, (n) => n.name.text);
 }
+function analyzeNamedTypeToIRFromProgramContext(ctx, filePath, typeName, extensionRegistry) {
+  const analysisFilePath = path.resolve(filePath);
+  const classDecl = findClassByName(ctx.sourceFile, typeName);
+  if (classDecl !== null) {
+    return analyzeClassToIR(classDecl, ctx.checker, analysisFilePath, extensionRegistry);
+  }
+  const interfaceDecl = findInterfaceByName(ctx.sourceFile, typeName);
+  if (interfaceDecl !== null) {
+    return analyzeInterfaceToIR(interfaceDecl, ctx.checker, analysisFilePath, extensionRegistry);
+  }
+  const typeAlias = findTypeAliasByName(ctx.sourceFile, typeName);
+  if (typeAlias !== null) {
+    const result = analyzeTypeAliasToIR(
+      typeAlias,
+      ctx.checker,
+      analysisFilePath,
+      extensionRegistry
+    );
+    if (result.ok) {
+      return result.analysis;
+    }
+    throw new Error(result.error);
+  }
+  throw new Error(
+    `Type "${typeName}" not found as a class, interface, or type alias in ${analysisFilePath}`
+  );
+}
+
+// src/generators/class-schema.ts
+var ts5 = require("typescript");
 
 // src/json-schema/ir-generator.ts
 function makeContext(options) {
@@ -3415,12 +3459,14 @@ function collectFormSpecReferences(methods) {
 0 && (module.exports = {
   analyzeClassToIR,
   analyzeInterfaceToIR,
+  analyzeNamedTypeToIRFromProgramContext,
   analyzeTypeAliasToIR,
   canonicalizeChainDSL,
   canonicalizeTSDoc,
   collectFormSpecReferences,
   createExtensionRegistry,
   createProgramContext,
+  createProgramContextFromProgram,
   findClassByName,
   findInterfaceByName,
   findTypeAliasByName,