schema-components 1.12.10 → 1.13.0

package/dist/core/types.d.mts

@@ -1,3 +1,2 @@
-import { C as HtmlResolver, E as RenderProps, S as HtmlRenderProps, T as RenderFunction, _ as WalkedField, a as FromJSONSchema, b as ComponentResolver, c as InferResponseFields, d as OpenAPIResponseType, f as PathOfType, g as TypeAtPath, h as SchemaType, i as FieldOverrides, l as JsonObject, m as SchemaMeta, n as FieldConstraints, o as InferParameterOverrides, p as ResolveOpenAPIRef, r as FieldOverride, s as InferRequestBodyFields, t as Editability, u as OpenAPIRequestBodyType, v as resolveEditability, x as HtmlRenderFunction, y as BaseFieldProps } from "../types-BJzEgJdX.mjs";
-import { i as SchemaRenderError, n as SchemaFieldError, r as SchemaNormalisationError, t as SchemaError } from "../errors-DIKI2C78.mjs";
-export { BaseFieldProps, ComponentResolver, Editability, FieldConstraints, FieldOverride, FieldOverrides, FromJSONSchema, HtmlRenderFunction, HtmlRenderProps, HtmlResolver, InferParameterOverrides, InferRequestBodyFields, InferResponseFields, JsonObject, OpenAPIRequestBodyType, OpenAPIResponseType, PathOfType, RenderFunction, RenderProps, ResolveOpenAPIRef, SchemaError, SchemaFieldError, SchemaMeta, SchemaNormalisationError, SchemaRenderError, SchemaType, TypeAtPath, WalkedField, resolveEditability };
+import { A as UnknownField, B as isNullField, C as RecursiveField, D as StringField, E as StringConstraints, F as isDiscriminatedUnionField, G as isStringField, H as isObjectField, I as isEnumField, J as isUnknownField, K as isTupleField, L as isFileField, M as isArrayField, N as isBooleanField, O as TupleField, P as isConditionalField, R as isLiteralField, S as RecordField, T as SchemaType, U as isRecordField, V as isNumberField, W as isRecursiveField, Y as resolveEditability, _ as NullField, a as DiscriminatedUnionField, b as ObjectConstraints, c as FieldBase, d as FieldOverrides, f as FileConstraints, g as NegationField, h as LiteralField, i as ConditionalField, j as WalkedField, k as UnionField, l as FieldConstraints, m as JsonObject, n as ArrayField, o as Editability, p as FileField, q as isUnionField, r as BooleanField, s as EnumField, t as ArrayConstraints, u as FieldOverride, v as NumberConstraints, w as SchemaMeta, x as ObjectField, y as NumberField, z as isNegationField } from "../types-ag2jYLqQ.mjs";
+export { ArrayConstraints, ArrayField, BooleanField, ConditionalField, DiscriminatedUnionField, Editability, EnumField, FieldBase, FieldConstraints, FieldOverride, FieldOverrides, FileConstraints, FileField, JsonObject, LiteralField, NegationField, NullField, NumberConstraints, NumberField, ObjectConstraints, ObjectField, RecordField, RecursiveField, SchemaMeta, SchemaType, StringConstraints, StringField, TupleField, UnionField, UnknownField, WalkedField, isArrayField, isBooleanField, isConditionalField, isDiscriminatedUnionField, isEnumField, isFileField, isLiteralField, isNegationField, isNullField, isNumberField, isObjectField, isRecordField, isRecursiveField, isStringField, isTupleField, isUnionField, isUnknownField, resolveEditability };

package/dist/core/types.mjs

@@ -1,4 +1,3 @@
-import { SchemaError, SchemaFieldError, SchemaNormalisationError, SchemaRenderError } from "./errors.mjs";
 //#region src/core/types.ts
 /**
 * Resolved editability state for a single field.
@@ -36,5 +35,59 @@ function resolveEditability(propertyMeta, componentMeta, rootMeta) {
 	if (rootMeta !== void 0 && ("readOnly" in rootMeta || "writeOnly" in rootMeta)) return "editable";
 	return "editable";
 }
+function isField(field, t) {
+	return field.type === t;
+}
+function isStringField(field) {
+	return isField(field, "string");
+}
+function isNumberField(field) {
+	return isField(field, "number");
+}
+function isBooleanField(field) {
+	return isField(field, "boolean");
+}
+function isNullField(field) {
+	return isField(field, "null");
+}
+function isEnumField(field) {
+	return isField(field, "enum");
+}
+function isLiteralField(field) {
+	return isField(field, "literal");
+}
+function isObjectField(field) {
+	return isField(field, "object");
+}
+function isArrayField(field) {
+	return isField(field, "array");
+}
+function isTupleField(field) {
+	return isField(field, "tuple");
+}
+function isRecordField(field) {
+	return isField(field, "record");
+}
+function isUnionField(field) {
+	return isField(field, "union");
+}
+function isDiscriminatedUnionField(field) {
+	return isField(field, "discriminatedUnion");
+}
+function isConditionalField(field) {
+	return isField(field, "conditional");
+}
+function isNegationField(field) {
+	return isField(field, "negation");
+}
+function isFileField(field) {
+	return isField(field, "file");
+}
+function isRecursiveField(field) {
+	return isField(field, "recursive");
+}
+function isUnknownField(field) {
+	return isField(field, "unknown");
+}
 //#endregion
-export { SchemaError, SchemaFieldError, SchemaNormalisationError, SchemaRenderError, resolveEditability };
+export { isArrayField, isBooleanField, isConditionalField, isDiscriminatedUnionField, isEnumField, isFileField, isLiteralField, isNegationField, isNullField, isNumberField, isObjectField, isRecordField, isRecursiveField, isStringField, isTupleField, isUnionField, isUnknownField, resolveEditability };

package/dist/core/version.d.mts

@@ -0,0 +1,2 @@
+import { a as isOpenApi30, i as detectOpenApiVersion, n as OpenApiVersionInfo, o as isOpenApi31, r as detectJsonSchemaDraft, s as isSwagger2, t as JsonSchemaDraft } from "../version-CLchheaH.mjs";
+export { JsonSchemaDraft, OpenApiVersionInfo, detectJsonSchemaDraft, detectOpenApiVersion, isOpenApi30, isOpenApi31, isSwagger2 };

package/dist/core/version.mjs

@@ -0,0 +1,79 @@
+//#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.
+* Returns `"draft-2020-12"` as the default when `$schema` is absent —
+* this is the most compatible assumption for modern schemas.
+*/
+function detectJsonSchemaDraft(schema) {
+	const $schema = schema.$schema;
+	if (typeof $schema !== "string") return "draft-2020-12";
+	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";
+}
+/**
+* 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, isOpenApi30, isOpenApi31, isSwagger2 };

package/dist/core/walkBuilders.d.mts

@@ -0,0 +1,52 @@
+import { A as UnknownField, D as StringField, _ as NullField, c as FieldBase, j as WalkedField, o as Editability, p as FileField, r as BooleanField, w as SchemaMeta, y as NumberField } from "../types-ag2jYLqQ.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;
+}
+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>;
+}
+/**
+ * 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)
+	};
+}
+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 { j as WalkedField } from "../types-ag2jYLqQ.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 };