@formspec/build 0.1.0-alpha.31 → 0.1.0-alpha.32

package/dist/cli.cjs

@@ -2987,6 +2987,27 @@ function resolveNodeMetadata(metadataPolicy, declarationKind, logicalName, node,
     makeMetadataContext("tsdoc", declarationKind, logicalName, buildContext)
   );
 }
+function analyzeDeclarationRootInfo(declaration, checker, file = "", extensionRegistry, metadataPolicy) {
+  const normalizedMetadataPolicy = normalizeMetadataPolicy(metadataPolicy);
+  const declarationType = checker.getTypeAtLocation(declaration);
+  const logicalName = ts3.isClassDeclaration(declaration) ? declaration.name?.text ?? "AnonymousClass" : declaration.name.text;
+  const docResult = extractJSDocParseResult(
+    declaration,
+    file,
+    makeParseOptions(extensionRegistry, void 0, checker, declarationType, declarationType)
+  );
+  const metadata = resolveNodeMetadata(normalizedMetadataPolicy, "type", logicalName, declaration, {
+    checker,
+    declaration,
+    subjectType: declarationType,
+    hostType: declarationType
+  });
+  return {
+    ...metadata !== void 0 && { metadata },
+    annotations: docResult.annotations,
+    diagnostics: docResult.diagnostics
+  };
+}
 function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry, metadataPolicy) {
   const normalizedMetadataPolicy = normalizeMetadataPolicy(metadataPolicy);
   const name = classDecl.name?.text ?? "AnonymousClass";
@@ -3401,10 +3422,7 @@ function resolveLiteralDiscriminatorPropertyValue(boundType, fieldName, checker,
   if (resolvedAnchorNode === null) {
     return void 0;
   }
-  const propertyType = checker.getTypeOfSymbolAtLocation(
-    propertySymbol,
-    resolvedAnchorNode
-  );
+  const propertyType = checker.getTypeOfSymbolAtLocation(propertySymbol, resolvedAnchorNode);
   if (propertyType.isStringLiteral()) {
     return propertyType.value;
   }
@@ -4363,14 +4381,39 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, sourceNo
       collectedDiagnostics
     );
     const fieldNodeInfo = fieldInfoMap?.get(prop.name);
+    const inlineFieldNodeInfo = fieldNodeInfo === void 0 ? ts3.isPropertySignature(declaration) ? analyzeInterfacePropertyToIR(
+      declaration,
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      collectedDiagnostics,
+      type,
+      metadataPolicy,
+      extensionRegistry
+    ) : ts3.isPropertyDeclaration(declaration) ? analyzeFieldToIR(
+      declaration,
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      collectedDiagnostics,
+      type,
+      metadataPolicy,
+      extensionRegistry
+    ) : null : null;
+    const resolvedFieldNodeInfo = fieldNodeInfo ?? inlineFieldNodeInfo;
+    const resolvedPropertyType = inlineFieldNodeInfo?.type ?? propTypeNode;
     properties.push({
       name: prop.name,
-      ...fieldNodeInfo?.metadata !== void 0 && { metadata: fieldNodeInfo.metadata },
-      type: propTypeNode,
+      ...resolvedFieldNodeInfo?.metadata !== void 0 && {
+        metadata: resolvedFieldNodeInfo.metadata
+      },
+      type: resolvedPropertyType,
       optional,
-      constraints: fieldNodeInfo?.constraints ?? [],
-      annotations: fieldNodeInfo?.annotations ?? [],
-      provenance: fieldNodeInfo?.provenance ?? provenanceForFile(file)
+      constraints: resolvedFieldNodeInfo?.constraints ?? [],
+      annotations: resolvedFieldNodeInfo?.annotations ?? [],
+      provenance: resolvedFieldNodeInfo?.provenance ?? provenanceForFile(file)
     });
   }
   visiting.delete(type);
@@ -5018,6 +5061,362 @@ var init_class_schema = __esm({
   }
 });
 
+// src/static-build.ts
+function toStaticBuildContext(context) {
+  return context;
+}
+function createStaticBuildContext(filePath) {
+  return toStaticBuildContext(createProgramContext(filePath));
+}
+function createStaticBuildContextFromProgram(program, filePath) {
+  return toStaticBuildContext(createProgramContextFromProgram(program, filePath));
+}
+function getModuleSymbol(context) {
+  const sourceFileWithSymbol = context.sourceFile;
+  return context.checker.getSymbolAtLocation(context.sourceFile) ?? sourceFileWithSymbol.symbol;
+}
+function isSchemaSourceDeclaration(declaration) {
+  return ts6.isClassDeclaration(declaration) || ts6.isInterfaceDeclaration(declaration) || ts6.isTypeAliasDeclaration(declaration);
+}
+function resolveModuleExport(context, exportName = "default") {
+  const moduleSymbol = getModuleSymbol(context);
+  if (moduleSymbol === void 0) {
+    return null;
+  }
+  const exportSymbol = context.checker.getExportsOfModule(moduleSymbol).find((candidate) => candidate.name === exportName) ?? null;
+  if (exportSymbol === null) {
+    return null;
+  }
+  return exportSymbol.flags & ts6.SymbolFlags.Alias ? context.checker.getAliasedSymbol(exportSymbol) : exportSymbol;
+}
+function resolveModuleExportDeclaration(context, exportName = "default") {
+  return resolveModuleExport(context, exportName)?.declarations?.find(isSchemaSourceDeclaration) ?? null;
+}
+var ts6;
+var init_static_build = __esm({
+  "src/static-build.ts"() {
+    "use strict";
+    ts6 = __toESM(require("typescript"), 1);
+    init_program();
+  }
+});
+
+// src/generators/discovered-schema.ts
+function toDiscoveredTypeSchemas(result) {
+  return result;
+}
+function isNamedTypeDeclaration(declaration) {
+  return ts7.isClassDeclaration(declaration) || ts7.isInterfaceDeclaration(declaration) || ts7.isTypeAliasDeclaration(declaration);
+}
+function hasConcreteTypeArguments(type, checker) {
+  if ("aliasTypeArguments" in type && Array.isArray(type.aliasTypeArguments) && type.aliasTypeArguments.length > 0) {
+    return true;
+  }
+  if ((type.flags & ts7.TypeFlags.Object) === 0) {
+    return false;
+  }
+  const objectType = type;
+  if ((objectType.objectFlags & ts7.ObjectFlags.Reference) === 0) {
+    return false;
+  }
+  return checker.getTypeArguments(objectType).length > 0;
+}
+function getNamedTypeDeclaration2(type) {
+  const symbol = type.getSymbol();
+  if (symbol?.declarations !== void 0) {
+    const declaration = symbol.declarations[0];
+    if (declaration !== void 0 && isNamedTypeDeclaration(declaration)) {
+      return declaration;
+    }
+  }
+  const aliasDeclaration = type.aliasSymbol?.declarations?.find(ts7.isTypeAliasDeclaration);
+  return aliasDeclaration;
+}
+function getFallbackName(sourceNode, fallback = "AnonymousType") {
+  if (sourceNode !== void 0 && "name" in sourceNode) {
+    const namedNode = sourceNode;
+    if (namedNode.name !== void 0 && ts7.isIdentifier(namedNode.name)) {
+      return namedNode.name.text;
+    }
+  }
+  return fallback;
+}
+function createObjectRootAnalysis(name, properties, typeRegistry, metadata, annotations) {
+  const fields = properties.map((property) => ({
+    kind: "field",
+    name: property.name,
+    ...property.metadata !== void 0 && { metadata: property.metadata },
+    type: property.type,
+    required: !property.optional,
+    constraints: property.constraints,
+    annotations: property.annotations,
+    provenance: property.provenance
+  }));
+  return {
+    name,
+    ...metadata !== void 0 && { metadata },
+    fields,
+    fieldLayouts: fields.map(() => ({})),
+    typeRegistry,
+    ...annotations !== void 0 && annotations.length > 0 && { annotations },
+    instanceMethods: [],
+    staticMethods: [],
+    diagnostics: []
+  };
+}
+function omitApiName(metadata) {
+  if (metadata?.apiName === void 0) {
+    return metadata;
+  }
+  const { apiName: _apiName, ...rest } = metadata;
+  return Object.keys(rest).length > 0 ? rest : void 0;
+}
+function describeRootType(rootType, typeRegistry, fallbackName) {
+  if (rootType.kind !== "reference") {
+    return {
+      name: fallbackName,
+      type: rootType
+    };
+  }
+  const definition = typeRegistry[rootType.name];
+  if (definition === void 0) {
+    return {
+      name: rootType.name,
+      type: rootType
+    };
+  }
+  return {
+    name: definition.name,
+    ...definition.metadata !== void 0 && { metadata: definition.metadata },
+    ...definition.annotations !== void 0 && definition.annotations.length > 0 && { annotations: definition.annotations },
+    type: definition.type
+  };
+}
+function toStandaloneJsonSchema(root, typeRegistry, options) {
+  const syntheticFieldMetadata = omitApiName(root.metadata);
+  const syntheticField = {
+    kind: "field",
+    name: "__result",
+    ...syntheticFieldMetadata !== void 0 && { metadata: syntheticFieldMetadata },
+    type: root.type,
+    required: true,
+    constraints: [],
+    annotations: [...root.annotations ?? []],
+    provenance: {
+      surface: "tsdoc",
+      file: "",
+      line: 1,
+      column: 0
+    }
+  };
+  const schema = generateJsonSchemaFromIR(
+    {
+      kind: "form-ir",
+      name: root.name,
+      irVersion: import_internals5.IR_VERSION,
+      elements: [syntheticField],
+      ...root.metadata !== void 0 && { metadata: root.metadata },
+      ...root.annotations !== void 0 && root.annotations.length > 0 && { rootAnnotations: root.annotations },
+      typeRegistry,
+      provenance: syntheticField.provenance
+    },
+    {
+      extensionRegistry: options?.extensionRegistry,
+      vendorPrefix: options?.vendorPrefix
+    }
+  );
+  const result = schema.properties?.["__result"];
+  if (result === void 0) {
+    throw new Error("FormSpec failed to extract the standalone schema root from the synthetic IR.");
+  }
+  if (schema.$defs === void 0 || Object.keys(schema.$defs).length === 0) {
+    return {
+      ...schema.$schema !== void 0 && { $schema: schema.$schema },
+      ...result
+    };
+  }
+  return {
+    ...schema.$schema !== void 0 && { $schema: schema.$schema },
+    ...result,
+    $defs: schema.$defs
+  };
+}
+function generateSchemasFromAnalysis(analysis, filePath, options) {
+  return toDiscoveredTypeSchemas(
+    generateClassSchemas(
+      analysis,
+      { file: filePath },
+      {
+        extensionRegistry: options?.extensionRegistry,
+        metadata: options?.metadata,
+        vendorPrefix: options?.vendorPrefix
+      }
+    )
+  );
+}
+function generateSchemasFromResolvedType(options, skipNamedDeclaration = false, rootOverride) {
+  const namedDeclaration = skipNamedDeclaration || hasConcreteTypeArguments(options.type, options.context.checker) ? void 0 : getNamedTypeDeclaration2(options.type);
+  if (namedDeclaration !== void 0) {
+    return generateSchemasFromDeclaration({
+      ...options,
+      declaration: namedDeclaration
+    });
+  }
+  const filePath = options.sourceNode?.getSourceFile().fileName ?? options.context.sourceFile.fileName;
+  const typeRegistry = {};
+  const diagnostics = [];
+  const rootType = resolveTypeNode(
+    options.type,
+    options.context.checker,
+    filePath,
+    typeRegistry,
+    /* @__PURE__ */ new Set(),
+    options.sourceNode,
+    normalizeMetadataPolicy(options.metadata),
+    options.extensionRegistry,
+    diagnostics
+  );
+  if (diagnostics.length > 0) {
+    const diagnosticDetails = diagnostics.map((diagnostic) => `${diagnostic.code}: ${diagnostic.message}`).join("; ");
+    throw new Error(
+      `FormSpec validation failed while generating discovered type schemas. ${diagnosticDetails}`
+    );
+  }
+  const describedRoot = describeRootType(
+    rootType,
+    typeRegistry,
+    options.name ?? getFallbackName(options.sourceNode)
+  );
+  const mergedMetadata = mergeResolvedMetadata(describedRoot.metadata, rootOverride?.metadata);
+  const root = {
+    ...describedRoot,
+    ...rootOverride?.name !== void 0 && { name: rootOverride.name },
+    ...mergedMetadata !== void 0 && { metadata: mergedMetadata },
+    ...rootOverride?.annotations !== void 0 && { annotations: rootOverride.annotations }
+  };
+  if (root.type.kind === "object") {
+    return generateSchemasFromAnalysis(
+      createObjectRootAnalysis(
+        options.name ?? root.name,
+        root.type.properties,
+        typeRegistry,
+        root.metadata,
+        root.annotations
+      ),
+      filePath,
+      options
+    );
+  }
+  return {
+    jsonSchema: toStandaloneJsonSchema(root, typeRegistry, options),
+    uiSchema: null
+  };
+}
+function generateSchemasFromDeclaration(options) {
+  const filePath = options.declaration.getSourceFile().fileName;
+  if (ts7.isClassDeclaration(options.declaration)) {
+    return generateSchemasFromAnalysis(
+      analyzeClassToIR(
+        options.declaration,
+        options.context.checker,
+        filePath,
+        options.extensionRegistry,
+        options.metadata
+      ),
+      filePath,
+      options
+    );
+  }
+  if (ts7.isInterfaceDeclaration(options.declaration)) {
+    return generateSchemasFromAnalysis(
+      analyzeInterfaceToIR(
+        options.declaration,
+        options.context.checker,
+        filePath,
+        options.extensionRegistry,
+        options.metadata
+      ),
+      filePath,
+      options
+    );
+  }
+  if (ts7.isTypeAliasDeclaration(options.declaration)) {
+    const analyzedAlias = analyzeTypeAliasToIR(
+      options.declaration,
+      options.context.checker,
+      filePath,
+      options.extensionRegistry,
+      options.metadata
+    );
+    if (analyzedAlias.ok) {
+      return generateSchemasFromAnalysis(analyzedAlias.analysis, filePath, options);
+    }
+    const aliasRootInfo = analyzeDeclarationRootInfo(
+      options.declaration,
+      options.context.checker,
+      filePath,
+      options.extensionRegistry,
+      options.metadata
+    );
+    if (aliasRootInfo.diagnostics.length > 0) {
+      const diagnosticDetails = aliasRootInfo.diagnostics.map((diagnostic) => `${diagnostic.code}: ${diagnostic.message}`).join("; ");
+      throw new Error(
+        `FormSpec validation failed while generating discovered type schemas. ${diagnosticDetails}`
+      );
+    }
+    return generateSchemasFromResolvedType(
+      {
+        ...options,
+        type: options.context.checker.getTypeAtLocation(options.declaration),
+        sourceNode: options.declaration,
+        name: options.declaration.name.text
+      },
+      true,
+      {
+        name: options.declaration.name.text,
+        ...aliasRootInfo.metadata !== void 0 && { metadata: aliasRootInfo.metadata },
+        ...aliasRootInfo.annotations.length > 0 && { annotations: aliasRootInfo.annotations }
+      }
+    );
+  }
+  const _exhaustive = options.declaration;
+  return _exhaustive;
+}
+function generateSchemasFromType(options) {
+  return generateSchemasFromResolvedType(options);
+}
+function generateSchemasFromParameter(options) {
+  return generateSchemasFromResolvedType({
+    ...options,
+    type: options.context.checker.getTypeAtLocation(options.parameter),
+    sourceNode: options.parameter,
+    name: getFallbackName(options.parameter, "Parameter")
+  });
+}
+function generateSchemasFromReturnType(options) {
+  const signature = options.context.checker.getSignatureFromDeclaration(options.declaration);
+  const type = signature !== void 0 ? options.context.checker.getReturnTypeOfSignature(signature) : options.context.checker.getTypeAtLocation(options.declaration);
+  const fallbackName = options.declaration.name !== void 0 && ts7.isIdentifier(options.declaration.name) ? `${options.declaration.name.text}ReturnType` : "ReturnType";
+  return generateSchemasFromResolvedType({
+    ...options,
+    type,
+    sourceNode: options.declaration.type ?? options.declaration,
+    name: fallbackName
+  });
+}
+var ts7, import_internals5;
+var init_discovered_schema = __esm({
+  "src/generators/discovered-schema.ts"() {
+    "use strict";
+    ts7 = __toESM(require("typescript"), 1);
+    init_class_analyzer();
+    init_class_schema();
+    init_ir_generator();
+    import_internals5 = require("@formspec/core/internals");
+    init_metadata();
+  }
+});
+
 // src/generators/mixed-authoring.ts
 function buildMixedAuthoringSchemas(options) {
   const { filePath, typeName, overlays, ...schemaOptions } = options;
@@ -5224,12 +5623,20 @@ __export(index_exports, {
   buildFormSchemas: () => buildFormSchemas,
   buildMixedAuthoringSchemas: () => buildMixedAuthoringSchemas,
   createExtensionRegistry: () => createExtensionRegistry,
+  createStaticBuildContext: () => createStaticBuildContext,
+  createStaticBuildContextFromProgram: () => createStaticBuildContextFromProgram,
   generateJsonSchema: () => generateJsonSchema,
   generateSchemas: () => generateSchemas,
   generateSchemasFromClass: () => generateSchemasFromClass,
+  generateSchemasFromDeclaration: () => generateSchemasFromDeclaration,
+  generateSchemasFromParameter: () => generateSchemasFromParameter,
   generateSchemasFromProgram: () => generateSchemasFromProgram,
+  generateSchemasFromReturnType: () => generateSchemasFromReturnType,
+  generateSchemasFromType: () => generateSchemasFromType,
   generateUiSchema: () => generateUiSchema,
   jsonSchema7Schema: () => jsonSchema7Schema,
+  resolveModuleExport: () => resolveModuleExport,
+  resolveModuleExportDeclaration: () => resolveModuleExportDeclaration,
   uiSchemaSchema: () => uiSchema,
   writeSchemas: () => writeSchemas
 });
@@ -5267,6 +5674,8 @@ var init_index = __esm({
     init_generator();
     init_generator2();
     init_class_schema();
+    init_static_build();
+    init_discovered_schema();
     init_mixed_authoring();
   }
 });