@formspec/build 0.1.0-alpha.36 → 0.1.0-alpha.38

package/dist/cli.js

@@ -2237,6 +2237,16 @@ function buildSupportingDeclarations(sourceFile, extensionTypeNames) {
     return true;
   }).map((statement) => statement.getText(sourceFile));
 }
+function pushUniqueCompilerDiagnostics(target, additions) {
+  for (const diagnostic of additions) {
+    if ((diagnostic.code === "UNSUPPORTED_CUSTOM_TYPE_OVERRIDE" || diagnostic.code === "SYNTHETIC_SETUP_FAILURE") && target.some(
+      (existing) => existing.code === diagnostic.code && existing.message === diagnostic.message
+    )) {
+      continue;
+    }
+    target.push(diagnostic);
+  }
+}
 function renderSyntheticArgumentExpression(valueKind, argumentText) {
   const trimmed = argumentText.trim();
   if (trimmed === "") {
@@ -2503,6 +2513,16 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
   if (result.diagnostics.length === 0) {
     return [];
   }
+  const setupDiagnostic = result.diagnostics.find((diagnostic) => diagnostic.kind !== "typescript");
+  if (setupDiagnostic !== void 0) {
+    return [
+      makeDiagnostic(
+        setupDiagnostic.kind === "unsupported-custom-type-override" ? "UNSUPPORTED_CUSTOM_TYPE_OVERRIDE" : "SYNTHETIC_SETUP_FAILURE",
+        setupDiagnostic.message,
+        provenance
+      )
+    ];
+  }
   const expectedLabel = definition.valueKind === null ? "compatible argument" : capabilityLabel(definition.valueKind);
   return [
     makeDiagnostic(
@@ -2666,7 +2686,7 @@ function parseTSDocTags(node, file = "", options) {
           options
         );
         if (compilerDiagnostics.length > 0) {
-          diagnostics.push(...compilerDiagnostics);
+          pushUniqueCompilerDiagnostics(diagnostics, compilerDiagnostics);
           continue;
         }
         const constraintNode = parseConstraintTagValue(
@@ -2753,7 +2773,7 @@ function parseTSDocTags(node, file = "", options) {
         options
       );
       if (compilerDiagnostics.length > 0) {
-        diagnostics.push(...compilerDiagnostics);
+        pushUniqueCompilerDiagnostics(diagnostics, compilerDiagnostics);
         continue;
       }
       const constraintNode = parseConstraintTagValue(
@@ -2787,7 +2807,7 @@ function parseTSDocTags(node, file = "", options) {
         options
       );
       if (compilerDiagnostics.length > 0) {
-        diagnostics.push(...compilerDiagnostics);
+        pushUniqueCompilerDiagnostics(diagnostics, compilerDiagnostics);
         continue;
       }
       const constraintNode = parseConstraintTagValue(
@@ -3016,6 +3036,21 @@ function isObjectType(type) {
 function isIntersectionType(type) {
   return !!(type.flags & ts3.TypeFlags.Intersection);
 }
+function isResolvableObjectLikeAliasTypeNode(typeNode) {
+  if (ts3.isParenthesizedTypeNode(typeNode)) {
+    return isResolvableObjectLikeAliasTypeNode(typeNode.type);
+  }
+  if (ts3.isTypeLiteralNode(typeNode) || ts3.isTypeReferenceNode(typeNode)) {
+    return true;
+  }
+  return ts3.isIntersectionTypeNode(typeNode) && typeNode.types.length > 0 && typeNode.types.every((member) => isResolvableObjectLikeAliasTypeNode(member));
+}
+function isSemanticallyPlainObjectLikeType(type, checker) {
+  if (isIntersectionType(type)) {
+    return type.types.length > 0 && type.types.every((member) => isSemanticallyPlainObjectLikeType(member, checker));
+  }
+  return isObjectType(type) && checker.getSignaturesOfType(type, ts3.SignatureKind.Call).length === 0 && checker.getSignaturesOfType(type, ts3.SignatureKind.Construct).length === 0 && !checker.isArrayType(type) && !checker.isTupleType(type);
+}
 function isTypeReference(type) {
   return !!(type.flags & ts3.TypeFlags.Object) && !!(type.objectFlags & ts3.ObjectFlags.Reference);
 }
@@ -3268,6 +3303,7 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry,
     const kindDesc = ts3.SyntaxKind[typeAlias.type.kind] ?? "unknown";
     return {
       ok: false,
+      kind: "not-object-like",
       error: `Type alias "${typeAlias.name.text}" at line ${String(line + 1)} is not an object-like type alias (found ${kindDesc})`
     };
   }
@@ -3282,6 +3318,7 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry,
     const { line } = sourceFile.getLineAndCharacterOfPosition(typeAlias.getStart());
     return {
       ok: false,
+      kind: "duplicate-properties",
       error: `Type alias "${name}" at line ${String(line + 1)} contains duplicate property names across object-like members: ${duplicatePropertyNames.join(", ")}`
     };
   }
@@ -3978,10 +4015,10 @@ function findDuplicateObjectLikeTypeAliasPropertyNames(members) {
   return [...duplicates].sort();
 }
 function getAnalyzableObjectLikePropertyName(name) {
-  if (!ts3.isIdentifier(name)) {
-    return null;
+  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name) || ts3.isNumericLiteral(name)) {
+    return name.text;
   }
-  return name.text;
+  return null;
 }
 function applyEnumMemberDisplayNames(type, annotations) {
   if (!annotations.some(
@@ -4191,6 +4228,19 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
         diagnostics
       );
     }
+    if (resolvedSourceTypeNode !== void 0 && isResolvableObjectLikeAliasTypeNode(resolvedSourceTypeNode) && isSemanticallyPlainObjectLikeType(type, checker)) {
+      return resolveObjectType(
+        type,
+        checker,
+        file,
+        typeRegistry,
+        visiting,
+        sourceNode,
+        metadataPolicy,
+        extensionRegistry,
+        diagnostics
+      );
+    }
   }
   if (isObjectType(type)) {
     return resolveObjectType(
@@ -5114,6 +5164,95 @@ function findInterfaceByName(sourceFile, interfaceName) {
 function findTypeAliasByName(sourceFile, aliasName) {
   return findNodeByName(sourceFile, aliasName, ts4.isTypeAliasDeclaration, (n) => n.name.text);
 }
+function getResolvedObjectRootType(rootType, typeRegistry) {
+  if (rootType.kind === "object") {
+    return rootType;
+  }
+  if (rootType.kind !== "reference") {
+    return null;
+  }
+  const definition = typeRegistry[rootType.name];
+  return definition?.type.kind === "object" ? definition.type : null;
+}
+function createResolvedObjectAliasAnalysis(name, rootType, typeRegistry, rootInfo, diagnostics) {
+  const resolvedRootType = getResolvedObjectRootType(rootType, typeRegistry);
+  if (resolvedRootType === null) {
+    return null;
+  }
+  const fields = resolvedRootType.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,
+    ...rootInfo.metadata !== void 0 && { metadata: rootInfo.metadata },
+    fields,
+    fieldLayouts: fields.map(() => ({})),
+    typeRegistry,
+    ...rootInfo.annotations.length > 0 && { annotations: [...rootInfo.annotations] },
+    ...diagnostics.length > 0 && { diagnostics: [...diagnostics] },
+    instanceMethods: [],
+    staticMethods: []
+  };
+}
+function containsTypeReferenceInObjectLikeAlias(typeNode) {
+  if (ts4.isParenthesizedTypeNode(typeNode)) {
+    return containsTypeReferenceInObjectLikeAlias(typeNode.type);
+  }
+  if (ts4.isTypeReferenceNode(typeNode)) {
+    return true;
+  }
+  return ts4.isIntersectionTypeNode(typeNode) && typeNode.types.some((member) => containsTypeReferenceInObjectLikeAlias(member));
+}
+function collectFallbackAliasMemberPropertyNames(typeNode, checker) {
+  if (ts4.isParenthesizedTypeNode(typeNode)) {
+    return collectFallbackAliasMemberPropertyNames(typeNode.type, checker);
+  }
+  if (ts4.isTypeLiteralNode(typeNode)) {
+    const propertyNames = [];
+    for (const member of typeNode.members) {
+      if (!ts4.isPropertySignature(member)) {
+        continue;
+      }
+      const propertyName = getAnalyzableObjectLikePropertyName(member.name);
+      if (propertyName !== null) {
+        propertyNames.push(propertyName);
+      }
+    }
+    return propertyNames;
+  }
+  if (ts4.isTypeReferenceNode(typeNode)) {
+    return checker.getTypeFromTypeNode(typeNode).getProperties().map((property) => property.getName());
+  }
+  return null;
+}
+function findFallbackAliasDuplicatePropertyNames(typeNode, checker) {
+  if (!ts4.isIntersectionTypeNode(typeNode)) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const member of typeNode.types) {
+    const propertyNames = collectFallbackAliasMemberPropertyNames(member, checker);
+    if (propertyNames === null) {
+      continue;
+    }
+    for (const propertyName of propertyNames) {
+      if (seen.has(propertyName)) {
+        duplicates.add(propertyName);
+      } else {
+        seen.add(propertyName);
+      }
+    }
+  }
+  return [...duplicates].sort();
+}
 function analyzeNamedTypeToIR(filePath, typeName, extensionRegistry, metadataPolicy, discriminatorOptions) {
   const ctx = createProgramContext(filePath);
   return analyzeNamedTypeToIRFromProgramContext(
@@ -5162,6 +5301,51 @@ function analyzeNamedTypeToIRFromProgramContext(ctx, filePath, typeName, extensi
     if (result.ok) {
       return result.analysis;
     }
+    const fallbackEligible = result.kind === "not-object-like" && isResolvableObjectLikeAliasTypeNode(typeAlias.type) && containsTypeReferenceInObjectLikeAlias(typeAlias.type);
+    if (!fallbackEligible) {
+      throw new Error(result.error);
+    }
+    const duplicatePropertyNames = findFallbackAliasDuplicatePropertyNames(
+      typeAlias.type,
+      ctx.checker
+    );
+    if (duplicatePropertyNames.length > 0) {
+      const sourceFile = typeAlias.getSourceFile();
+      const { line } = sourceFile.getLineAndCharacterOfPosition(typeAlias.getStart());
+      throw new Error(
+        `Type alias "${typeAlias.name.text}" at line ${String(line + 1)} contains duplicate property names across object-like members: ${duplicatePropertyNames.join(", ")}`
+      );
+    }
+    const rootInfo = analyzeDeclarationRootInfo(
+      typeAlias,
+      ctx.checker,
+      analysisFilePath,
+      extensionRegistry,
+      metadataPolicy
+    );
+    const diagnostics = [...rootInfo.diagnostics];
+    const typeRegistry = {};
+    const rootType = resolveTypeNode(
+      ctx.checker.getTypeAtLocation(typeAlias),
+      ctx.checker,
+      analysisFilePath,
+      typeRegistry,
+      /* @__PURE__ */ new Set(),
+      typeAlias,
+      createAnalyzerMetadataPolicy(metadataPolicy, discriminatorOptions),
+      extensionRegistry,
+      diagnostics
+    );
+    const fallbackAnalysis = createResolvedObjectAliasAnalysis(
+      typeAlias.name.text,
+      rootType,
+      typeRegistry,
+      rootInfo,
+      diagnostics
+    );
+    if (fallbackAnalysis !== null) {
+      return fallbackAnalysis;
+    }
     throw new Error(result.error);
   }
   throw new Error(
@@ -5704,15 +5888,36 @@ function generateSchemasFromParameter(options) {
 }
 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 returnType = signature !== void 0 ? options.context.checker.getReturnTypeOfSignature(signature) : options.context.checker.getTypeAtLocation(options.declaration);
+  const type = unwrapPromiseType(options.context.checker, returnType);
+  const sourceNode = type !== returnType ? unwrapPromiseTypeNode(options.declaration.type) ?? options.declaration.type ?? options.declaration : options.declaration.type ?? 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,
+    sourceNode,
     name: fallbackName
   });
 }
+function unwrapPromiseType(checker, type) {
+  if (!("getAwaitedType" in checker) || typeof checker.getAwaitedType !== "function") {
+    return type;
+  }
+  return checker.getAwaitedType(type) ?? type;
+}
+function unwrapPromiseTypeNode(typeNode) {
+  if (typeNode === void 0) {
+    return void 0;
+  }
+  if (ts7.isParenthesizedTypeNode(typeNode)) {
+    const unwrapped = unwrapPromiseTypeNode(typeNode.type);
+    return unwrapped ?? typeNode;
+  }
+  return isPromiseTypeReferenceNode(typeNode) ? typeNode.typeArguments[0] : typeNode;
+}
+function isPromiseTypeReferenceNode(typeNode) {
+  return ts7.isTypeReferenceNode(typeNode) && ts7.isIdentifier(typeNode.typeName) && typeNode.typeName.text === "Promise" && typeNode.typeArguments !== void 0 && typeNode.typeArguments.length > 0;
+}
 var init_discovered_schema = __esm({
   "src/generators/discovered-schema.ts"() {
     "use strict";