schema-components 1.12.11 → 1.14.0

package/dist/core/version.mjs

@@ -0,0 +1,151 @@
+//#region src/core/version.ts
+/**
+* $schema URI prefixes mapped to their draft version.
+* Draft 04–07 use `http://json-schema.org/draft-XX/schema#`.
+* Draft 2019-09 and 2020-12 use `https://json-schema.org/draft/YYYY-MM/schema`.
+*/
+const DRAFT_URIS = new Map([
+	["https://json-schema.org/draft/2020-12/schema", "draft-2020-12"],
+	["https://json-schema.org/draft/2019-09/schema", "draft-2019-09"],
+	["http://json-schema.org/draft-07/schema#", "draft-07"],
+	["https://json-schema.org/draft-07/schema#", "draft-07"],
+	["http://json-schema.org/draft-06/schema#", "draft-06"],
+	["https://json-schema.org/draft-06/schema#", "draft-06"],
+	["http://json-schema.org/draft-04/schema#", "draft-04"],
+	["https://json-schema.org/draft-04/schema#", "draft-04"]
+]);
+/**
+* Detect the JSON Schema draft version from a schema's `$schema` URI.
+* When `$schema` is absent, uses heuristic keyword detection via
+* `inferJsonSchemaDraft` to guess the draft version.
+* Returns `"draft-2020-12"` as the final fallback when no heuristic
+* matches either.
+*/
+function detectJsonSchemaDraft(schema) {
+	const $schema = schema.$schema;
+	if (typeof $schema === "string") {
+		const exact = DRAFT_URIS.get($schema);
+		if (exact !== void 0) return exact;
+		for (const [uri, draft] of DRAFT_URIS) if ($schema.startsWith(uri) || $schema === uri) return draft;
+		if ($schema.includes("/draft/2020-12/")) return "draft-2020-12";
+		if ($schema.includes("/draft/2019-09/")) return "draft-2019-09";
+		if ($schema.includes("/draft-07")) return "draft-07";
+		if ($schema.includes("/draft-06")) return "draft-06";
+		if ($schema.includes("/draft-04")) return "draft-04";
+		return "draft-2020-12";
+	}
+	return inferJsonSchemaDraft(schema);
+}
+/**
+* Infer the JSON Schema draft from keyword presence when `$schema`
+* is absent. Examined from highest-confidence to lowest.
+*
+* Heuristics:
+* 1. `$dynamicRef` / `$dynamicAnchor` / `prefixItems` → Draft 2020-12
+* 2. `$recursiveRef` / `$recursiveAnchor` / `unevaluatedProperties` /
+*    `dependentSchemas` → Draft 2019-09
+* 3. `if` / `then` / `else`, `contentEncoding` / `contentMediaType` → Draft 07
+* 4. `const`, `examples` (array), `propertyNames` → Draft 06
+* 5. Boolean `exclusiveMinimum`, `id` (no `$`), `definitions` only → Draft 04
+* 6. No signal → Draft 2020-12
+*/
+function inferJsonSchemaDraft(schema) {
+	if ("$dynamicRef" in schema || "$dynamicAnchor" in schema || "prefixItems" in schema) return "draft-2020-12";
+	if ("$recursiveRef" in schema || "$recursiveAnchor" in schema || "unevaluatedProperties" in schema || "unevaluatedItems" in schema) return "draft-2019-09";
+	if ("if" in schema || "then" in schema || "else" in schema) return "draft-07";
+	if ("contentEncoding" in schema || "contentMediaType" in schema) return "draft-07";
+	if ("const" in schema || "propertyNames" in schema) return "draft-06";
+	const examples = schema.examples;
+	if (Array.isArray(examples)) return "draft-06";
+	if (typeof schema.exclusiveMinimum === "boolean" || typeof schema.exclusiveMaximum === "boolean") return "draft-04";
+	if ("id" in schema && !("$id" in schema)) return "draft-04";
+	return "draft-2020-12";
+}
+/**
+* Like `inferJsonSchemaDraft` but also returns the heuristic that
+* triggered the inference, for diagnostic emission.
+*/
+function inferJsonSchemaDraftWithReason(schema) {
+	if ("$dynamicRef" in schema || "$dynamicAnchor" in schema || "prefixItems" in schema) return {
+		draft: "draft-2020-12",
+		inferredFrom: "dynamic-ref-or-anchor-or-prefixItems"
+	};
+	if ("$recursiveRef" in schema || "$recursiveAnchor" in schema || "unevaluatedProperties" in schema || "unevaluatedItems" in schema) return {
+		draft: "draft-2019-09",
+		inferredFrom: "recursive-ref-or-anchor-or-unevaluated"
+	};
+	if ("if" in schema || "then" in schema || "else" in schema) return {
+		draft: "draft-07",
+		inferredFrom: "if-then-else"
+	};
+	if ("contentEncoding" in schema || "contentMediaType" in schema) return {
+		draft: "draft-07",
+		inferredFrom: "content-encoding-or-media-type"
+	};
+	if ("const" in schema || "propertyNames" in schema) return {
+		draft: "draft-06",
+		inferredFrom: "const-or-propertyNames"
+	};
+	const examples = schema.examples;
+	if (Array.isArray(examples)) return {
+		draft: "draft-06",
+		inferredFrom: "examples"
+	};
+	if (typeof schema.exclusiveMinimum === "boolean" || typeof schema.exclusiveMaximum === "boolean") return {
+		draft: "draft-04",
+		inferredFrom: "boolean-exclusive-min-max"
+	};
+	if ("id" in schema && !("$id" in schema)) return {
+		draft: "draft-04",
+		inferredFrom: "id-without-dollar"
+	};
+	return {
+		draft: "draft-2020-12",
+		inferredFrom: "no-signal"
+	};
+}
+/**
+* Detect the OpenAPI/Swagger version from a document.
+* Returns `undefined` for documents that are not OpenAPI or Swagger.
+*/
+function detectOpenApiVersion(doc) {
+	const swagger = doc.swagger;
+	if (typeof swagger === "string") {
+		const parts = swagger.split(".").map(Number);
+		return {
+			major: parts[0] ?? 2,
+			minor: parts[1] ?? 0,
+			patch: parts[2] ?? 0
+		};
+	}
+	const openapi = doc.openapi;
+	if (typeof openapi === "string") {
+		const parts = openapi.split(".").map(Number);
+		return {
+			major: parts[0] ?? 3,
+			minor: parts[1] ?? 0,
+			patch: parts[2] ?? 0
+		};
+	}
+}
+/**
+* Check if an OpenAPI version is 3.0.x (uses modified Draft 04 schemas
+* with `nullable` instead of `anyOf [T, null]`).
+*/
+function isOpenApi30(version) {
+	return version.major === 3 && version.minor === 0;
+}
+/**
+* Check if an OpenAPI version is 3.1.x (uses standard Draft 2020-12).
+*/
+function isOpenApi31(version) {
+	return version.major === 3 && version.minor === 1;
+}
+/**
+* Check if a document is Swagger 2.0.
+*/
+function isSwagger2(version) {
+	return version.major === 2;
+}
+//#endregion
+export { detectJsonSchemaDraft, detectOpenApiVersion, inferJsonSchemaDraft, inferJsonSchemaDraftWithReason, isOpenApi30, isOpenApi31, isSwagger2 };

package/dist/core/walkBuilders.d.mts

@@ -0,0 +1,66 @@
+import { M as WalkedField, O as StringField, T as SchemaMeta, b as NumberField, c as FieldBase, j as UnknownField, o as Editability, p as FileField, r as BooleanField, v as NullField } from "../types-D_5ST7SS.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-DzbZmcLI.mjs";
+import { t as ExternalResolver } from "../ref-DvWoULcy.mjs";
+
+//#region src/core/walkBuilders.d.ts
+declare function getString(obj: Record<string, unknown>, key: string): string | undefined;
+declare function getArray(obj: Record<string, unknown>, key: string): unknown[] | undefined;
+declare function getObject(obj: Record<string, unknown>, key: string): Record<string, unknown> | undefined;
+interface WalkOptions {
+  componentMeta?: SchemaMeta | undefined;
+  rootMeta?: SchemaMeta | undefined;
+  /** Nested field overrides — same shape as the schema. */
+  fieldOverrides?: Record<string, unknown> | undefined;
+  /** The root document for $ref resolution. */
+  rootDocument?: Record<string, unknown> | undefined;
+  /** Diagnostics channel for surfacing silent fallbacks. */
+  diagnostics?: DiagnosticsOptions;
+  /** Sync resolver for external $ref URIs. */
+  externalResolver?: ExternalResolver;
+}
+declare function extractMetaFromJson(schema: Record<string, unknown>): SchemaMeta;
+declare function extractSchemaMetaFields(overrides: Record<string, unknown> | undefined): SchemaMeta | undefined;
+declare function extractChildOverride(overrides: Record<string, unknown> | undefined, key: string): Record<string, unknown> | undefined;
+interface WalkContext {
+  componentMeta: SchemaMeta | undefined;
+  rootMeta: SchemaMeta | undefined;
+  fieldOverrides: Record<string, unknown> | undefined;
+  rootDocument: Record<string, unknown>;
+  isNullable: boolean;
+  isOptional: boolean;
+  defaultValue: unknown;
+  /** Cache of $ref → WalkedField for recursive schema support. */
+  refResults: Map<string, WalkedField>;
+  /** JSON Pointer tracking for diagnostics. */
+  pointer: string;
+  /** Diagnostics channel for surfacing silent fallbacks. */
+  diagnostics: DiagnosticsOptions | undefined;
+  /** Derived $ref depth bound from the root document. */
+  maxRefDepth: number;
+  /** Sync resolver for external $ref URIs. */
+  externalResolver: ExternalResolver | undefined;
+}
+/**
+ * Build the common base shared by every field variant.
+ */
+declare function buildBase(schema: Record<string, unknown>, ctx: WalkContext): FieldBase & {
+  editability: Editability;
+};
+declare function buildStringField(schema: Record<string, unknown>, ctx: WalkContext): StringField;
+declare function buildNumberField(schema: Record<string, unknown>, ctx: WalkContext): NumberField;
+declare function buildBooleanField(schema: Record<string, unknown>, ctx: WalkContext): BooleanField;
+declare function buildNullField(schema: Record<string, unknown>, ctx: WalkContext): NullField;
+declare function buildUnknownField(schema: Record<string, unknown>, ctx: WalkContext): UnknownField;
+declare function buildFileField(schema: Record<string, unknown>, ctx: WalkContext): FileField;
+/** Walk a map of sub-schemas (patternProperties, dependentSchemas). */
+declare function walkSubSchemaMap<T>(map: Record<string, unknown>, walkNode: (schema: Record<string, unknown>, ctx: WalkContext) => T, ctx: WalkContext): Record<string, T>;
+/** Walk a dependentRequired map (Record<string, string[]>). */
+declare function walkDependentRequiredMap(map: Record<string, unknown>): Record<string, string[]>;
+/**
+ * Return a copy of the schema without the specified keys.
+ * Used to strip composition keywords before walking the base schema.
+ */
+declare function withoutKeys(schema: Record<string, unknown>, keys: string[]): Record<string, unknown>;
+declare function isPrimitive(value: unknown): value is string | number | boolean | null;
+//#endregion
+export { WalkContext, WalkOptions, buildBase, buildBooleanField, buildFileField, buildNullField, buildNumberField, buildStringField, buildUnknownField, extractChildOverride, extractMetaFromJson, extractSchemaMetaFields, getArray, getObject, getString, isPrimitive, walkDependentRequiredMap, walkSubSchemaMap, withoutKeys };

package/dist/core/walkBuilders.mjs

@@ -0,0 +1,152 @@
+import { isObject } from "./guards.mjs";
+import { extractFileConstraints, extractNumberConstraints, extractStringConstraints } from "./constraints.mjs";
+import { resolveEditability } from "./types.mjs";
+//#region src/core/walkBuilders.ts
+function getString(obj, key) {
+	const value = obj[key];
+	return typeof value === "string" ? value : void 0;
+}
+function getArray(obj, key) {
+	const value = obj[key];
+	return Array.isArray(value) ? value : void 0;
+}
+function getObject(obj, key) {
+	const value = obj[key];
+	return isObject(value) ? value : void 0;
+}
+const META_KEYWORDS = new Set([
+	"readOnly",
+	"writeOnly",
+	"description",
+	"title",
+	"deprecated",
+	"default",
+	"component",
+	"example",
+	"examples"
+]);
+function extractMetaFromJson(schema) {
+	const meta = {};
+	for (const [key, value] of Object.entries(schema)) if (META_KEYWORDS.has(key)) meta[key] = value;
+	return meta;
+}
+const OVERRIDE_META_KEYS = new Set([
+	"readOnly",
+	"writeOnly",
+	"description",
+	"title",
+	"deprecated",
+	"component",
+	"visible",
+	"order"
+]);
+function extractSchemaMetaFields(overrides) {
+	if (overrides === void 0) return void 0;
+	const meta = {};
+	for (const key of Object.keys(overrides)) if (OVERRIDE_META_KEYS.has(key)) meta[key] = overrides[key];
+	return Object.keys(meta).length > 0 ? meta : void 0;
+}
+function extractChildOverride(overrides, key) {
+	if (overrides === void 0) return void 0;
+	const child = overrides[key];
+	if (child === void 0 || child === null) return void 0;
+	if (typeof child !== "object" || Array.isArray(child)) return void 0;
+	const result = {};
+	for (const [k, v] of Object.entries(child)) result[k] = v;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/**
+* Build the common base shared by every field variant.
+*/
+function buildBase(schema, ctx) {
+	const propertyMeta = extractMetaFromJson(schema);
+	const overrideMeta = extractSchemaMetaFields(ctx.fieldOverrides);
+	const mergedMeta = {
+		...propertyMeta,
+		...overrideMeta
+	};
+	const defaultValue = "default" in schema ? schema.default : void 0;
+	const examplesRaw = schema.examples;
+	const examples = Array.isArray(examplesRaw) ? examplesRaw : void 0;
+	const editability = resolveEditability(mergedMeta, ctx.componentMeta, ctx.rootMeta);
+	if ((overrideMeta !== void 0 && ("readOnly" in overrideMeta || "writeOnly" in overrideMeta) || Boolean(propertyMeta.readOnly) || Boolean(propertyMeta.writeOnly)) && ctx.componentMeta !== void 0) ctx = {
+		...ctx,
+		componentMeta: void 0
+	};
+	return {
+		editability,
+		meta: mergedMeta,
+		isOptional: ctx.isOptional,
+		isNullable: ctx.isNullable,
+		defaultValue: defaultValue ?? ctx.defaultValue,
+		...examples !== void 0 ? { examples } : {}
+	};
+}
+function buildStringField(schema, ctx) {
+	return {
+		...buildBase(schema, ctx),
+		type: "string",
+		constraints: extractStringConstraints(schema, ctx.diagnostics, ctx.pointer)
+	};
+}
+function buildNumberField(schema, ctx) {
+	return {
+		...buildBase(schema, ctx),
+		type: "number",
+		constraints: extractNumberConstraints(schema)
+	};
+}
+function buildBooleanField(schema, ctx) {
+	return {
+		...buildBase(schema, ctx),
+		type: "boolean",
+		constraints: {}
+	};
+}
+function buildNullField(schema, ctx) {
+	return {
+		...buildBase(schema, ctx),
+		type: "null",
+		constraints: {}
+	};
+}
+function buildUnknownField(schema, ctx) {
+	return {
+		...buildBase(schema, ctx),
+		type: "unknown",
+		constraints: {}
+	};
+}
+function buildFileField(schema, ctx) {
+	return {
+		...buildBase(schema, ctx),
+		type: "file",
+		constraints: extractFileConstraints(schema)
+	};
+}
+/** Walk a map of sub-schemas (patternProperties, dependentSchemas). */
+function walkSubSchemaMap(map, walkNode, ctx) {
+	const result = {};
+	for (const [key, value] of Object.entries(map)) if (isObject(value)) result[key] = walkNode(value, ctx);
+	return result;
+}
+/** Walk a dependentRequired map (Record<string, string[]>). */
+function walkDependentRequiredMap(map) {
+	const result = {};
+	for (const [key, value] of Object.entries(map)) if (Array.isArray(value)) result[key] = value.filter((x) => typeof x === "string");
+	return result;
+}
+/**
+* Return a copy of the schema without the specified keys.
+* Used to strip composition keywords before walking the base schema.
+*/
+function withoutKeys(schema, keys) {
+	const result = {};
+	for (const [key, value] of Object.entries(schema)) if (!keys.includes(key)) result[key] = value;
+	return result;
+}
+function isPrimitive(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null;
+}
+//#endregion
+export { buildBase, buildBooleanField, buildFileField, buildNullField, buildNumberField, buildStringField, buildUnknownField, extractChildOverride, extractMetaFromJson, extractSchemaMetaFields, getArray, getObject, getString, isPrimitive, walkDependentRequiredMap, walkSubSchemaMap, withoutKeys };

package/dist/core/walker.d.mts

@@ -1,14 +1,7 @@
-import { _ as WalkedField, m as SchemaMeta } from "../types-BJzEgJdX.mjs";
+import { M as WalkedField } from "../types-D_5ST7SS.mjs";
+import { WalkOptions } from "./walkBuilders.mjs";
 
 //#region src/core/walker.d.ts
-interface WalkOptions {
-  componentMeta?: SchemaMeta | undefined;
-  rootMeta?: SchemaMeta | undefined;
-  /** Nested field overrides — same shape as the schema. */
-  fieldOverrides?: Record<string, unknown> | undefined;
-  /** The root document for $ref resolution. */
-  rootDocument?: Record<string, unknown> | undefined;
-}
 declare function walk(schema: unknown, options?: WalkOptions): WalkedField;
 //#endregion
-export { WalkOptions, walk };
+export { walk };