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

package/dist/generators/class-schema.d.ts

@@ -9,10 +9,11 @@ import type { UISchema } from "../ui-schema/types.js";
 import { type IRClassAnalysis } from "../analyzer/class-analyzer.js";
 import { type TSDocSource } from "../canonicalize/index.js";
 import { type GenerateJsonSchemaFromIROptions, type JsonSchema2020 } from "../json-schema/ir-generator.js";
+import type { ExtensionRegistry } from "../extensions/index.js";
 /**
  * Generated schemas for a class.
  *
- * @public
+ * @beta
  */
 export interface ClassSchemas {
     /** JSON Schema 2020-12 for validation */
@@ -31,12 +32,28 @@ export interface ClassSchemas {
  * @returns Generated JSON Schema and UI Schema
  */
 export declare function generateClassSchemas(analysis: IRClassAnalysis, source?: TSDocSource, options?: GenerateJsonSchemaFromIROptions): ClassSchemas;
+/**
+ * Shared options for schema generation flows that support custom extensions.
+ *
+ * @public
+ */
+export interface StaticSchemaGenerationOptions {
+    /**
+     * Registry used to resolve custom types, constraints, and annotations.
+     */
+    readonly extensionRegistry?: ExtensionRegistry | undefined;
+    /**
+     * Vendor prefix for emitted extension keywords.
+     * @defaultValue "x-formspec"
+     */
+    readonly vendorPrefix?: string | undefined;
+}
 /**
  * Options for generating schemas from a decorated class.
  *
  * @public
  */
-export interface GenerateFromClassOptions extends GenerateJsonSchemaFromIROptions {
+export interface GenerateFromClassOptions extends StaticSchemaGenerationOptions {
     /** Path to the TypeScript source file */
     filePath: string;
     /** Class name to analyze */
@@ -80,7 +97,7 @@ export declare function generateSchemasFromClass(options: GenerateFromClassOptio
  *
  * @public
  */
-export interface GenerateSchemasOptions extends GenerateJsonSchemaFromIROptions {
+export interface GenerateSchemasOptions extends StaticSchemaGenerationOptions {
     /** Path to the TypeScript source file */
     filePath: string;
     /** Name of the exported class, interface, or type alias to analyze */

package/dist/generators/class-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"class-schema.d.ts","sourceRoot":"","sources":["../../src/generators/class-schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAMtD,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACvF,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC/E,OAAO,EAEL,KAAK,+BAA+B,EACpC,KAAK,cAAc,EACpB,MAAM,gCAAgC,CAAC;AAIxC;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,UAAU,EAAE,cAAc,CAAC;IAC3B,yCAAyC;IACzC,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,eAAe,EACzB,MAAM,CAAC,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,+BAA+B,GACxC,YAAY,CAuBd;AAmBD;;;;GAIG;AACH,MAAM,WAAW,wBAAyB,SAAQ,+BAA+B;IAC/E,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,4BAA4B;IAC5B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,yCAAyC;IACzC,UAAU,EAAE,cAAc,CAAC;IAC3B,yCAAyC;IACzC,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,wBAAwB,GAChC,uBAAuB,CAsBzB;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAuB,SAAQ,+BAA+B;IAC7E,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,uBAAuB,CAOxF"}
+{"version":3,"file":"class-schema.d.ts","sourceRoot":"","sources":["../../src/generators/class-schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAMtD,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACvF,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC/E,OAAO,EAEL,KAAK,+BAA+B,EACpC,KAAK,cAAc,EACpB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAIhE;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,UAAU,EAAE,cAAc,CAAC;IAC3B,yCAAyC;IACzC,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,eAAe,EACzB,MAAM,CAAC,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,+BAA+B,GACxC,YAAY,CAuBd;AAmBD;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;OAEG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC3D;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5C;AAED;;;;GAIG;AACH,MAAM,WAAW,wBAAyB,SAAQ,6BAA6B;IAC7E,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,4BAA4B;IAC5B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,yCAAyC;IACzC,UAAU,EAAE,cAAc,CAAC;IAC3B,yCAAyC;IACzC,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,wBAAwB,GAChC,uBAAuB,CAsBzB;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAuB,SAAQ,6BAA6B;IAC3E,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,uBAAuB,CAOxF"}

package/dist/generators/mixed-authoring.d.ts

@@ -7,8 +7,9 @@
  * dynamic enum or dynamic schema metadata.
  */
 import type { FormElement, FormSpec } from "@formspec/core";
-import type { GenerateJsonSchemaFromIROptions, JsonSchema2020 } from "../json-schema/ir-generator.js";
+import type { JsonSchema2020 } from "../json-schema/ir-generator.js";
 import type { UISchema } from "../ui-schema/types.js";
+import type { StaticSchemaGenerationOptions } from "./class-schema.js";
 /**
  * Result of generating schemas from a mixed-authoring composition.
  *
@@ -28,7 +29,7 @@ export interface MixedAuthoringSchemas {
  *
  * @public
  */
-export interface BuildMixedAuthoringSchemasOptions extends GenerateJsonSchemaFromIROptions {
+export interface BuildMixedAuthoringSchemasOptions extends StaticSchemaGenerationOptions {
     /** Path to the TypeScript source file. */
     readonly filePath: string;
     /** Name of the class, interface, or type alias to analyze. */

package/dist/generators/mixed-authoring.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mixed-authoring.d.ts","sourceRoot":"","sources":["../../src/generators/mixed-authoring.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAGV,WAAW,EAEX,QAAQ,EAET,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EACV,+BAA+B,EAC/B,cAAc,EACf,MAAM,gCAAgC,CAAC;AAGxC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAKtD;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,0CAA0C;IAC1C,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,iCAAkC,SAAQ,+BAA+B;IACxF,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,2GAA2G;IAC3G,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,SAAS,WAAW,EAAE,CAAC,CAAC;CACrD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,iCAAiC,GACzC,qBAAqB,CAUvB"}
+{"version":3,"file":"mixed-authoring.d.ts","sourceRoot":"","sources":["../../src/generators/mixed-authoring.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,QAAQ,EACT,MAAM,gBAAgB,CAAC;AAOxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGrE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAItD,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAEvE;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,0CAA0C;IAC1C,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,iCAAkC,SAAQ,6BAA6B;IACtF,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,2GAA2G;IAC3G,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,SAAS,WAAW,EAAE,CAAC,CAAC;CACrD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,iCAAiC,GACzC,qBAAqB,CAUvB"}

package/dist/index.cjs

@@ -32,36 +32,17 @@ 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
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/canonicalize/chain-dsl-canonicalizer.ts
-var import_core = require("@formspec/core");
+var import_internals = require("@formspec/core/internals");
 var CHAIN_DSL_PROVENANCE = {
   surface: "chain-dsl",
   file: "",
@@ -80,7 +61,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: {},
@@ -373,7 +354,7 @@ function buildObjectProperties(elements, insideConditional = false) {
 }
 
 // src/canonicalize/tsdoc-canonicalizer.ts
-var import_core2 = require("@formspec/core");
+var import_internals2 = require("@formspec/core/internals");
 function canonicalizeTSDoc(analysis, source) {
   const file = source?.file ?? "";
   const provenance = {
@@ -385,7 +366,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 },
@@ -886,7 +867,8 @@ function assignVendorPrefixedExtensionKeywords(schema, extensionSchema, vendorPr
 // 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);
 }
 
 // src/ui-schema/schema.ts
@@ -1122,14 +1104,6 @@ function generateUiSchema(form) {
 var fs = __toESM(require("fs"), 1);
 var path2 = __toESM(require("path"), 1);
 
-// src/json-schema/types.ts
-function setSchemaExtension(schema, key, value) {
-  schema[key] = value;
-}
-function getSchemaExtension(schema, key) {
-  return schema[key];
-}
-
 // src/extensions/registry.ts
 function createExtensionRegistry(extensions) {
   const typeMap = /* @__PURE__ */ new Map();
@@ -1210,68 +1184,6 @@ function createExtensionRegistry(extensions) {
   };
 }
 
-// src/json-schema/schema.ts
-var import_zod3 = require("zod");
-var jsonSchemaTypeSchema = import_zod3.z.enum([
-  "string",
-  "number",
-  "integer",
-  "boolean",
-  "object",
-  "array",
-  "null"
-]);
-var 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/program.ts
 var ts4 = __toESM(require("typescript"), 1);
 var path = __toESM(require("path"), 1);
@@ -1286,11 +1198,12 @@ var ts2 = __toESM(require("typescript"), 1);
 var ts = __toESM(require("typescript"), 1);
 var import_internal = require("@formspec/analysis/internal");
 var import_tsdoc = require("@microsoft/tsdoc");
-var import_core3 = require("@formspec/core");
+var import_internals3 = require("@formspec/core/internals");
+var import_internals4 = require("@formspec/core/internals");
 var TAGS_REQUIRING_RAW_TEXT = /* @__PURE__ */ new Set(["pattern", "enumOptions", "defaultValue"]);
 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,
@@ -1333,10 +1246,71 @@ function sharedTagValueOptions(options) {
   };
 }
 var SYNTHETIC_TYPE_FORMAT_FLAGS = ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
+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();
@@ -1473,7 +1447,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;
@@ -1703,7 +1677,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);
@@ -1735,7 +1709,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(
@@ -1963,7 +1937,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;
@@ -3576,11 +3550,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 });
@@ -3595,30 +3566,11 @@ function writeSchemas(form, options) {
 0 && (module.exports = {
   buildFormSchemas,
   buildMixedAuthoringSchemas,
-  categorizationSchema,
-  categorySchema,
-  controlSchema,
   createExtensionRegistry,
   generateJsonSchema,
-  generateJsonSchemaFromIR,
   generateSchemas,
   generateSchemasFromClass,
   generateUiSchema,
-  getSchemaExtension,
-  groupLayoutSchema,
-  horizontalLayoutSchema,
-  jsonSchema7Schema,
-  jsonSchemaTypeSchema,
-  labelElementSchema,
-  ruleConditionSchema,
-  ruleEffectSchema,
-  ruleSchema,
-  schemaBasedConditionSchema,
-  setSchemaExtension,
-  uiSchemaElementSchema,
-  uiSchemaElementTypeSchema,
-  uiSchemaSchema,
-  verticalLayoutSchema,
   writeSchemas
 });
 //# sourceMappingURL=index.cjs.map