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

package/dist/cli.js

@@ -1212,6 +1212,74 @@ var init_extensions = __esm({
   }
 });
 
+// src/json-schema/schema.ts
+import { z as z3 } from "zod";
+var jsonSchemaTypeSchema, jsonSchema7Schema;
+var init_schema2 = __esm({
+  "src/json-schema/schema.ts"() {
+    "use strict";
+    jsonSchemaTypeSchema = z3.enum([
+      "string",
+      "number",
+      "integer",
+      "boolean",
+      "object",
+      "array",
+      "null"
+    ]);
+    jsonSchema7Schema = z3.lazy(
+      () => z3.object({
+        $schema: z3.string().optional(),
+        $id: z3.string().optional(),
+        $ref: z3.string().optional(),
+        // Metadata
+        title: z3.string().optional(),
+        description: z3.string().optional(),
+        deprecated: z3.boolean().optional(),
+        // Type
+        type: z3.union([jsonSchemaTypeSchema, z3.array(jsonSchemaTypeSchema)]).optional(),
+        // String validation
+        minLength: z3.number().optional(),
+        maxLength: z3.number().optional(),
+        pattern: z3.string().optional(),
+        // Number validation
+        minimum: z3.number().optional(),
+        maximum: z3.number().optional(),
+        exclusiveMinimum: z3.number().optional(),
+        exclusiveMaximum: z3.number().optional(),
+        // Enum
+        enum: z3.array(z3.union([z3.string(), z3.number(), z3.boolean(), z3.null()])).readonly().optional(),
+        const: z3.union([z3.string(), z3.number(), z3.boolean(), z3.null()]).optional(),
+        // Object
+        properties: z3.record(z3.string(), jsonSchema7Schema).optional(),
+        required: z3.array(z3.string()).optional(),
+        additionalProperties: z3.union([z3.boolean(), jsonSchema7Schema]).optional(),
+        // Array
+        items: z3.union([jsonSchema7Schema, z3.array(jsonSchema7Schema)]).optional(),
+        minItems: z3.number().optional(),
+        maxItems: z3.number().optional(),
+        // Composition
+        allOf: z3.array(jsonSchema7Schema).optional(),
+        anyOf: z3.array(jsonSchema7Schema).optional(),
+        oneOf: z3.array(jsonSchema7Schema).optional(),
+        not: jsonSchema7Schema.optional(),
+        // Conditional
+        if: jsonSchema7Schema.optional(),
+        then: jsonSchema7Schema.optional(),
+        else: jsonSchema7Schema.optional(),
+        // Format
+        format: z3.string().optional(),
+        // Default
+        default: z3.unknown().optional(),
+        // FormSpec extensions
+        "x-formspec-source": z3.string().optional(),
+        "x-formspec-params": z3.array(z3.string()).readonly().optional(),
+        "x-formspec-schemaSource": z3.string().optional()
+      }).passthrough()
+    );
+  }
+});
+
 // src/analyzer/tsdoc-parser.ts
 import * as ts from "typescript";
 import {
@@ -3207,6 +3275,18 @@ var init_class_analyzer = __esm({
 // src/analyzer/program.ts
 import * as ts4 from "typescript";
 import * as path from "path";
+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);
@@ -3277,24 +3357,33 @@ function findTypeAliasByName(sourceFile, aliasName) {
 }
 function analyzeNamedTypeToIR(filePath, typeName, extensionRegistry) {
   const ctx = createProgramContext(filePath);
+  return analyzeNamedTypeToIRFromProgramContext(ctx, filePath, typeName, extensionRegistry);
+}
+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, filePath, extensionRegistry);
+    return analyzeClassToIR(classDecl, ctx.checker, analysisFilePath, extensionRegistry);
   }
   const interfaceDecl = findInterfaceByName(ctx.sourceFile, typeName);
   if (interfaceDecl !== null) {
-    return analyzeInterfaceToIR(interfaceDecl, ctx.checker, filePath, extensionRegistry);
+    return analyzeInterfaceToIR(interfaceDecl, ctx.checker, analysisFilePath, extensionRegistry);
   }
   const typeAlias = findTypeAliasByName(ctx.sourceFile, typeName);
   if (typeAlias !== null) {
-    const result = analyzeTypeAliasToIR(typeAlias, ctx.checker, filePath, extensionRegistry);
+    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 ${filePath}`
+    `Type "${typeName}" not found as a class, interface, or type alias in ${analysisFilePath}`
   );
 }
 var init_program = __esm({
@@ -3393,6 +3482,7 @@ var init_validate = __esm({
 });
 
 // src/generators/class-schema.ts
+import "typescript";
 function generateClassSchemas(analysis, source, options) {
   const errorDiagnostics = analysis.diagnostics?.filter(
     (diagnostic) => diagnostic.severity === "error"
@@ -3449,12 +3539,28 @@ function generateSchemasFromClass(options) {
   );
 }
 function generateSchemas(options) {
-  const analysis = analyzeNamedTypeToIR(
+  const ctx = createProgramContext(options.filePath);
+  return generateSchemasFromProgram({
+    ...options,
+    program: ctx.program
+  });
+}
+function generateSchemasFromProgram(options) {
+  const ctx = createProgramContextFromProgram(options.program, options.filePath);
+  const analysis = analyzeNamedTypeToIRFromProgramContext(
+    ctx,
     options.filePath,
     options.typeName,
     options.extensionRegistry
   );
-  return generateClassSchemas(analysis, { file: options.filePath }, options);
+  return generateClassSchemas(
+    analysis,
+    { file: options.filePath },
+    {
+      extensionRegistry: options.extensionRegistry,
+      vendorPrefix: options.vendorPrefix
+    }
+  );
 }
 var init_class_schema = __esm({
   "src/generators/class-schema.ts"() {
@@ -3662,7 +3768,10 @@ __export(index_exports, {
   generateJsonSchema: () => generateJsonSchema,
   generateSchemas: () => generateSchemas,
   generateSchemasFromClass: () => generateSchemasFromClass,
+  generateSchemasFromProgram: () => generateSchemasFromProgram,
   generateUiSchema: () => generateUiSchema,
+  jsonSchema7Schema: () => jsonSchema7Schema,
+  uiSchemaSchema: () => uiSchema,
   writeSchemas: () => writeSchemas
 });
 import * as fs from "fs";
@@ -3693,6 +3802,8 @@ var init_index = __esm({
     init_generator2();
     init_ir_generator();
     init_extensions();
+    init_schema2();
+    init_schema();
     init_generator();
     init_generator2();
     init_class_schema();