@formspec/build 0.1.0-alpha.21 → 0.1.0-alpha.23

package/dist/canonicalize/chain-dsl-canonicalizer.d.ts

@@ -7,7 +7,8 @@
  * downstream phases (validation, JSON Schema generation, UI Schema generation)
  * consume.
  */
-import type { FormElement, FormSpec, FormIR } from "@formspec/core";
+import type { FormElement, FormSpec } from "@formspec/core";
+import type { FormIR } from "@formspec/core/internals";
 /**
  * Translates a chain DSL `FormSpec` into the canonical `FormIR`.
  *

package/dist/canonicalize/chain-dsl-canonicalizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chain-dsl-canonicalizer.d.ts","sourceRoot":"","sources":["../../src/canonicalize/chain-dsl-canonicalizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EASV,WAAW,EACX,QAAQ,EAiBR,MAAM,EAYP,MAAM,gBAAgB,CAAC;AAqCxB;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,WAAW,EAAE,CAAC,GAAG,MAAM,CASnF"}
+{"version":3,"file":"chain-dsl-canonicalizer.d.ts","sourceRoot":"","sources":["../../src/canonicalize/chain-dsl-canonicalizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EASV,WAAW,EACX,QAAQ,EAMT,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAYV,MAAM,EAYP,MAAM,0BAA0B,CAAC;AAqClC;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,WAAW,EAAE,CAAC,GAAG,MAAM,CASnF"}

package/dist/canonicalize/tsdoc-canonicalizer.d.ts

@@ -8,7 +8,7 @@
  * the layout metadata to wrap fields in `GroupLayoutNode` and
  * `ConditionalLayoutNode` elements.
  */
-import type { FormIR } from "@formspec/core";
+import type { FormIR } from "@formspec/core/internals";
 import type { IRClassAnalysis } from "../analyzer/class-analyzer.js";
 /**
  * Source-level metadata for provenance tracking.

package/dist/canonicalize/tsdoc-canonicalizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tsdoc-canonicalizer.d.ts","sourceRoot":"","sources":["../../src/canonicalize/tsdoc-canonicalizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,MAAM,EAMP,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,eAAe,EAAuB,MAAM,+BAA+B,CAAC;AAE1F;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,CAuBzF"}
+{"version":3,"file":"tsdoc-canonicalizer.d.ts","sourceRoot":"","sources":["../../src/canonicalize/tsdoc-canonicalizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,MAAM,EAMP,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,eAAe,EAAuB,MAAM,+BAA+B,CAAC;AAE1F;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,CAuBzF"}

package/dist/cli.cjs

@@ -43,7 +43,7 @@ function isField(el) {
 function canonicalizeChainDSL(form) {
   return {
     kind: "form-ir",
-    irVersion: import_core.IR_VERSION,
+    irVersion: import_internals.IR_VERSION,
     elements: canonicalizeElements(form.elements),
     rootAnnotations: [],
     typeRegistry: {},
@@ -334,11 +334,11 @@ function buildObjectProperties(elements, insideConditional = false) {
   }
   return properties;
 }
-var import_core, CHAIN_DSL_PROVENANCE;
+var import_internals, CHAIN_DSL_PROVENANCE;
 var init_chain_dsl_canonicalizer = __esm({
   "src/canonicalize/chain-dsl-canonicalizer.ts"() {
     "use strict";
-    import_core = require("@formspec/core");
+    import_internals = require("@formspec/core/internals");
     CHAIN_DSL_PROVENANCE = {
       surface: "chain-dsl",
       file: "",
@@ -360,7 +360,7 @@ function canonicalizeTSDoc(analysis, source) {
   const elements = assembleElements(analysis.fields, analysis.fieldLayouts, provenance);
   return {
     kind: "form-ir",
-    irVersion: import_core2.IR_VERSION,
+    irVersion: import_internals2.IR_VERSION,
     elements,
     typeRegistry: analysis.typeRegistry,
     ...analysis.annotations !== void 0 && analysis.annotations.length > 0 && { rootAnnotations: analysis.annotations },
@@ -422,11 +422,11 @@ function wrapInConditional(field, layout, provenance) {
   };
   return conditional;
 }
-var import_core2;
+var import_internals2;
 var init_tsdoc_canonicalizer = __esm({
   "src/canonicalize/tsdoc-canonicalizer.ts"() {
     "use strict";
-    import_core2 = require("@formspec/core");
+    import_internals2 = require("@formspec/core/internals");
   }
 });
 
@@ -882,7 +882,8 @@ var init_ir_generator = __esm({
 // src/json-schema/generator.ts
 function generateJsonSchema(form, options) {
   const ir = canonicalizeChainDSL(form);
-  return generateJsonSchemaFromIR(ir, options);
+  const internalOptions = options?.vendorPrefix === void 0 ? void 0 : { vendorPrefix: options.vendorPrefix };
+  return generateJsonSchemaFromIR(ir, internalOptions);
 }
 var init_generator = __esm({
   "src/json-schema/generator.ts"() {
@@ -1141,19 +1142,6 @@ var init_generator2 = __esm({
   }
 });
 
-// src/json-schema/types.ts
-function setSchemaExtension(schema, key, value) {
-  schema[key] = value;
-}
-function getSchemaExtension(schema, key) {
-  return schema[key];
-}
-var init_types = __esm({
-  "src/json-schema/types.ts"() {
-    "use strict";
-  }
-});
-
 // src/extensions/registry.ts
 function createExtensionRegistry(extensions) {
   const typeMap = /* @__PURE__ */ new Map();
@@ -1247,78 +1235,10 @@ var init_extensions = __esm({
   }
 });
 
-// src/json-schema/schema.ts
-var import_zod3, jsonSchemaTypeSchema, jsonSchema7Schema;
-var init_schema2 = __esm({
-  "src/json-schema/schema.ts"() {
-    "use strict";
-    import_zod3 = require("zod");
-    jsonSchemaTypeSchema = import_zod3.z.enum([
-      "string",
-      "number",
-      "integer",
-      "boolean",
-      "object",
-      "array",
-      "null"
-    ]);
-    jsonSchema7Schema = import_zod3.z.lazy(
-      () => import_zod3.z.object({
-        $schema: import_zod3.z.string().optional(),
-        $id: import_zod3.z.string().optional(),
-        $ref: import_zod3.z.string().optional(),
-        // Metadata
-        title: import_zod3.z.string().optional(),
-        description: import_zod3.z.string().optional(),
-        deprecated: import_zod3.z.boolean().optional(),
-        // Type
-        type: import_zod3.z.union([jsonSchemaTypeSchema, import_zod3.z.array(jsonSchemaTypeSchema)]).optional(),
-        // String validation
-        minLength: import_zod3.z.number().optional(),
-        maxLength: import_zod3.z.number().optional(),
-        pattern: import_zod3.z.string().optional(),
-        // Number validation
-        minimum: import_zod3.z.number().optional(),
-        maximum: import_zod3.z.number().optional(),
-        exclusiveMinimum: import_zod3.z.number().optional(),
-        exclusiveMaximum: import_zod3.z.number().optional(),
-        // Enum
-        enum: import_zod3.z.array(import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number(), import_zod3.z.boolean(), import_zod3.z.null()])).readonly().optional(),
-        const: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number(), import_zod3.z.boolean(), import_zod3.z.null()]).optional(),
-        // Object
-        properties: import_zod3.z.record(import_zod3.z.string(), jsonSchema7Schema).optional(),
-        required: import_zod3.z.array(import_zod3.z.string()).optional(),
-        additionalProperties: import_zod3.z.union([import_zod3.z.boolean(), jsonSchema7Schema]).optional(),
-        // Array
-        items: import_zod3.z.union([jsonSchema7Schema, import_zod3.z.array(jsonSchema7Schema)]).optional(),
-        minItems: import_zod3.z.number().optional(),
-        maxItems: import_zod3.z.number().optional(),
-        // Composition
-        allOf: import_zod3.z.array(jsonSchema7Schema).optional(),
-        anyOf: import_zod3.z.array(jsonSchema7Schema).optional(),
-        oneOf: import_zod3.z.array(jsonSchema7Schema).optional(),
-        not: jsonSchema7Schema.optional(),
-        // Conditional
-        if: jsonSchema7Schema.optional(),
-        then: jsonSchema7Schema.optional(),
-        else: jsonSchema7Schema.optional(),
-        // Format
-        format: import_zod3.z.string().optional(),
-        // Default
-        default: import_zod3.z.unknown().optional(),
-        // FormSpec extensions
-        "x-formspec-source": import_zod3.z.string().optional(),
-        "x-formspec-params": import_zod3.z.array(import_zod3.z.string()).readonly().optional(),
-        "x-formspec-schemaSource": import_zod3.z.string().optional()
-      }).passthrough()
-    );
-  }
-});
-
 // src/analyzer/tsdoc-parser.ts
 function createFormSpecTSDocConfig(extensionTagNames = []) {
   const config = new import_tsdoc.TSDocConfiguration();
-  for (const tagName of Object.keys(import_core3.BUILTIN_CONSTRAINT_DEFINITIONS)) {
+  for (const tagName of Object.keys(import_internals3.BUILTIN_CONSTRAINT_DEFINITIONS)) {
     config.addTagDefinition(
       new import_tsdoc.TSDocTagDefinition({
         tagName: "@" + tagName,
@@ -1360,10 +1280,71 @@ function sharedTagValueOptions(options) {
     ...options?.fieldType !== void 0 ? { fieldType: options.fieldType } : {}
   };
 }
+function collectImportedNames(sourceFile) {
+  const importedNames = /* @__PURE__ */ new Set();
+  for (const statement of sourceFile.statements) {
+    if (ts.isImportDeclaration(statement) && statement.importClause !== void 0) {
+      const clause = statement.importClause;
+      if (clause.name !== void 0) {
+        importedNames.add(clause.name.text);
+      }
+      if (clause.namedBindings !== void 0) {
+        if (ts.isNamedImports(clause.namedBindings)) {
+          for (const specifier of clause.namedBindings.elements) {
+            importedNames.add(specifier.name.text);
+          }
+        } else if (ts.isNamespaceImport(clause.namedBindings)) {
+          importedNames.add(clause.namedBindings.name.text);
+        }
+      }
+      continue;
+    }
+    if (ts.isImportEqualsDeclaration(statement)) {
+      importedNames.add(statement.name.text);
+    }
+  }
+  return importedNames;
+}
+function isNonReferenceIdentifier(node) {
+  const parent = node.parent;
+  if ((ts.isBindingElement(parent) || ts.isClassDeclaration(parent) || ts.isEnumDeclaration(parent) || ts.isEnumMember(parent) || ts.isFunctionDeclaration(parent) || ts.isFunctionExpression(parent) || ts.isImportClause(parent) || ts.isImportEqualsDeclaration(parent) || ts.isImportSpecifier(parent) || ts.isInterfaceDeclaration(parent) || ts.isMethodDeclaration(parent) || ts.isMethodSignature(parent) || ts.isModuleDeclaration(parent) || ts.isNamespaceExport(parent) || ts.isNamespaceImport(parent) || ts.isParameter(parent) || ts.isPropertyDeclaration(parent) || ts.isPropertySignature(parent) || ts.isSetAccessorDeclaration(parent) || ts.isGetAccessorDeclaration(parent) || ts.isTypeAliasDeclaration(parent) || ts.isTypeParameterDeclaration(parent) || ts.isVariableDeclaration(parent)) && parent.name === node) {
+    return true;
+  }
+  if ((ts.isPropertyAssignment(parent) || ts.isPropertyAccessExpression(parent)) && parent.name === node) {
+    return true;
+  }
+  if (ts.isQualifiedName(parent) && parent.right === node) {
+    return true;
+  }
+  return false;
+}
+function statementReferencesImportedName(statement, importedNames) {
+  let referencesImportedName = false;
+  const visit = (node) => {
+    if (referencesImportedName) {
+      return;
+    }
+    if (ts.isIdentifier(node) && importedNames.has(node.text) && !isNonReferenceIdentifier(node)) {
+      referencesImportedName = true;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(statement);
+  return referencesImportedName;
+}
 function buildSupportingDeclarations(sourceFile) {
-  return sourceFile.statements.filter(
-    (statement) => !ts.isImportDeclaration(statement) && !ts.isImportEqualsDeclaration(statement) && !(ts.isExportDeclaration(statement) && statement.moduleSpecifier !== void 0)
-  ).map((statement) => statement.getText(sourceFile));
+  const importedNames = collectImportedNames(sourceFile);
+  return sourceFile.statements.filter((statement) => {
+    if (ts.isImportDeclaration(statement)) return false;
+    if (ts.isImportEqualsDeclaration(statement)) return false;
+    if (ts.isExportDeclaration(statement) && statement.moduleSpecifier !== void 0)
+      return false;
+    if (importedNames.size > 0 && statementReferencesImportedName(statement, importedNames)) {
+      return false;
+    }
+    return true;
+  }).map((statement) => statement.getText(sourceFile));
 }
 function renderSyntheticArgumentExpression(valueKind, argumentText) {
   const trimmed = argumentText.trim();
@@ -1500,7 +1481,7 @@ function hasBuiltinConstraintBroadening(tagName, options) {
   return broadenedTypeId !== void 0 && options?.extensionRegistry?.findBuiltinConstraintBroadening(broadenedTypeId, tagName) !== void 0;
 }
 function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, parsedTag, provenance, supportingDeclarations, options) {
-  if (!(0, import_core3.isBuiltinConstraintName)(tagName)) {
+  if (!(0, import_internals3.isBuiltinConstraintName)(tagName)) {
     return [];
   }
   const checker = options?.checker;
@@ -1728,7 +1709,7 @@ function parseTSDocTags(node, file = "", options) {
         }
       }
       for (const block of docComment.customBlocks) {
-        const tagName = (0, import_core3.normalizeConstraintTagName)(block.blockTag.tagName.substring(1));
+        const tagName = (0, import_internals3.normalizeConstraintTagName)(block.blockTag.tagName.substring(1));
         const parsedTag = nextParsedTag(tagName);
         if (tagName === "displayName" || tagName === "format" || tagName === "placeholder") {
           const text2 = getBestBlockPayloadText(parsedTag, commentText, range.pos, block);
@@ -1760,7 +1741,7 @@ function parseTSDocTags(node, file = "", options) {
         }
         if (TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
         const text = getBestBlockPayloadText(parsedTag, commentText, range.pos, block);
-        const expectedType = (0, import_core3.isBuiltinConstraintName)(tagName) ? import_core3.BUILTIN_CONSTRAINT_DEFINITIONS[tagName] : void 0;
+        const expectedType = (0, import_internals3.isBuiltinConstraintName)(tagName) ? import_internals3.BUILTIN_CONSTRAINT_DEFINITIONS[tagName] : void 0;
         if (text === "" && expectedType !== "boolean") continue;
         const provenance = parsedTag !== null ? provenanceForParsedTag(parsedTag, sourceFile, file) : provenanceForComment(range, sourceFile, file, tagName);
         const compilerDiagnostics = buildCompilerBackedConstraintDiagnostics(
@@ -1988,7 +1969,7 @@ function getBestBlockPayloadText(tag, commentText, commentOffset, block) {
 function collectRawTextFallbacks(node, file) {
   const fallbacks = /* @__PURE__ */ new Map();
   for (const tag of ts.getJSDocTags(node)) {
-    const tagName = (0, import_core3.normalizeConstraintTagName)(tag.tagName.text);
+    const tagName = (0, import_internals3.normalizeConstraintTagName)(tag.tagName.text);
     if (!TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
     const commentText = getTagCommentText(tag)?.trim() ?? "";
     if (commentText === "") continue;
@@ -2044,14 +2025,15 @@ function getTagCommentText(tag) {
   }
   return ts.getTextOfJSDocComment(tag.comment);
 }
-var ts, import_internal, import_tsdoc, import_core3, TAGS_REQUIRING_RAW_TEXT, SYNTHETIC_TYPE_FORMAT_FLAGS, parserCache, parseResultCache;
+var ts, import_internal, import_tsdoc, import_internals3, import_internals4, TAGS_REQUIRING_RAW_TEXT, SYNTHETIC_TYPE_FORMAT_FLAGS, parserCache, parseResultCache;
 var init_tsdoc_parser = __esm({
   "src/analyzer/tsdoc-parser.ts"() {
     "use strict";
     ts = __toESM(require("typescript"), 1);
     import_internal = require("@formspec/analysis/internal");
     import_tsdoc = require("@microsoft/tsdoc");
-    import_core3 = require("@formspec/core");
+    import_internals3 = require("@formspec/core/internals");
+    import_internals4 = require("@formspec/core/internals");
     TAGS_REQUIRING_RAW_TEXT = /* @__PURE__ */ new Set(["pattern", "enumOptions", "defaultValue"]);
     SYNTHETIC_TYPE_FORMAT_FLAGS = ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
     parserCache = /* @__PURE__ */ new Map();
@@ -3672,30 +3654,11 @@ var index_exports = {};
 __export(index_exports, {
   buildFormSchemas: () => buildFormSchemas,
   buildMixedAuthoringSchemas: () => buildMixedAuthoringSchemas,
-  categorizationSchema: () => categorizationSchema,
-  categorySchema: () => categorySchema,
-  controlSchema: () => controlSchema,
   createExtensionRegistry: () => createExtensionRegistry,
   generateJsonSchema: () => generateJsonSchema,
-  generateJsonSchemaFromIR: () => generateJsonSchemaFromIR,
   generateSchemas: () => generateSchemas,
   generateSchemasFromClass: () => generateSchemasFromClass,
   generateUiSchema: () => generateUiSchema,
-  getSchemaExtension: () => getSchemaExtension,
-  groupLayoutSchema: () => groupLayoutSchema,
-  horizontalLayoutSchema: () => horizontalLayoutSchema,
-  jsonSchema7Schema: () => jsonSchema7Schema,
-  jsonSchemaTypeSchema: () => jsonSchemaTypeSchema,
-  labelElementSchema: () => labelElementSchema,
-  ruleConditionSchema: () => ruleConditionSchema,
-  ruleEffectSchema: () => ruleEffectSchema,
-  ruleSchema: () => ruleSchema,
-  schemaBasedConditionSchema: () => schemaBasedConditionSchema,
-  setSchemaExtension: () => setSchemaExtension,
-  uiSchemaElementSchema: () => uiSchemaElementSchema,
-  uiSchemaElementTypeSchema: () => uiSchemaElementTypeSchema,
-  uiSchemaSchema: () => uiSchema,
-  verticalLayoutSchema: () => verticalLayoutSchema,
   writeSchemas: () => writeSchemas
 });
 function buildFormSchemas(form, options) {
@@ -3705,11 +3668,8 @@ function buildFormSchemas(form, options) {
   };
 }
 function writeSchemas(form, options) {
-  const { outDir, name = "schema", indent = 2, extensionRegistry, vendorPrefix } = options;
-  const buildOptions = extensionRegistry === void 0 && vendorPrefix === void 0 ? void 0 : {
-    extensionRegistry,
-    vendorPrefix
-  };
+  const { outDir, name = "schema", indent = 2, vendorPrefix } = options;
+  const buildOptions = vendorPrefix === void 0 ? void 0 : { vendorPrefix };
   const { jsonSchema, uiSchema: uiSchema2 } = buildFormSchemas(form, buildOptions);
   if (!fs.existsSync(outDir)) {
     fs.mkdirSync(outDir, { recursive: true });
@@ -3729,12 +3689,8 @@ var init_index = __esm({
     init_ir_generator();
     fs = __toESM(require("fs"), 1);
     path2 = __toESM(require("path"), 1);
-    init_types();
     init_extensions();
-    init_schema();
-    init_schema2();
     init_generator();
-    init_ir_generator();
     init_generator2();
     init_class_schema();
     init_mixed_authoring();