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

package/dist/index.js

@@ -2906,6 +2906,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);
 }
@@ -3163,6 +3178,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})`
     };
   }
@@ -3177,6 +3193,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(", ")}`
     };
   }
@@ -3873,10 +3890,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(
@@ -4086,6 +4103,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(
@@ -4993,6 +5023,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(
@@ -5041,6 +5160,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(
@@ -5546,15 +5710,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;
+}
 
 // src/generators/mixed-authoring.ts
 function buildMixedAuthoringSchemas(options) {