schema-components 1.12.11 → 1.13.0

package/dist/types-BJzEgJdX.d.mts

@@ -1,335 +0,0 @@
-//#region src/core/renderer.d.ts
-/**
- * Properties available on every schema field, regardless of rendering target.
- * Both React and HTML renderers receive these.
- */
-interface BaseFieldProps {
-  /** Current field value. */
-  value: unknown;
-  /** Whether to render as read-only display. */
-  readOnly: boolean;
-  /** Whether to render as an empty input. */
-  writeOnly: boolean;
-  /** Schema metadata for this field. */
-  meta: SchemaMeta;
-  /** Constraints from schema checks. */
-  constraints: FieldConstraints;
-  /** Dot-separated path from root (e.g. "address.city"). */
-  path: string;
-  /** For enums: the allowed values. */
-  enumValues?: string[];
-  /** For arrays: the element schema. */
-  element?: WalkedField;
-  /** For objects: map of field name → WalkedField. */
-  fields?: Record<string, WalkedField>;
-  /** For unions: the option schemas. */
-  options?: WalkedField[];
-  /** For discriminated unions: the discriminator key. */
-  discriminator?: string;
-  /** For records: key and value schemas. */
-  keyType?: WalkedField;
-  valueType?: WalkedField;
-  /** Walked field tree for recursive rendering. */
-  tree: WalkedField;
-}
-/**
- * Props for React render functions. Extends BaseFieldProps with:
- * - `onChange` — callback to propagate value changes back to state
- * - `renderChild` — recursively renders a child field, threading onChange
- */
-interface RenderProps extends BaseFieldProps {
-  /** Callback to update the field value. */
-  onChange: (value: unknown) => void;
-  /**
-   * Render a child field. Theme adapters call this to recursively render
-   * nested structures (object fields, array elements, union options).
-   * The resolver and rendering context are already wired in.
-   */
-  renderChild: (tree: WalkedField, value: unknown, onChange: (v: unknown) => void) => unknown;
-}
-/**
- * Props for HTML render functions. Extends BaseFieldProps with:
- * - `renderChild` — recursively renders a child field to HTML string
- *
- * No `onChange` — HTML rendering is pure output with no event handling.
- */
-interface HtmlRenderProps extends BaseFieldProps {
-  /**
-   * Render a child field to an HTML string. Theme adapters call this
-   * to recursively render nested structures.
-   *
-   * @param tree - The walked field tree for the child
-   * @param value - The child's current value
-   * @param pathSuffix - Path segment from the parent (e.g. "city",
-   *   "[0]"). When omitted, the child's description is used as fallback.
-   */
-  renderChild: (tree: WalkedField, value: unknown, pathSuffix?: string) => string;
-}
-type RenderFunction = (props: RenderProps) => unknown;
-interface ComponentResolver {
-  string?: RenderFunction;
-  number?: RenderFunction;
-  boolean?: RenderFunction;
-  enum?: RenderFunction;
-  object?: RenderFunction;
-  array?: RenderFunction;
-  record?: RenderFunction;
-  union?: RenderFunction;
-  discriminatedUnion?: RenderFunction;
-  literal?: RenderFunction;
-  file?: RenderFunction;
-  unknown?: RenderFunction;
-}
-/** An HTML render function returns a string. */
-type HtmlRenderFunction = (props: HtmlRenderProps) => string;
-/**
- * HTML resolver — maps schema types to HTML string renderers.
- * Structurally mirrors ComponentResolver but produces strings.
- */
-interface HtmlResolver {
-  string?: HtmlRenderFunction;
-  number?: HtmlRenderFunction;
-  boolean?: HtmlRenderFunction;
-  enum?: HtmlRenderFunction;
-  object?: HtmlRenderFunction;
-  array?: HtmlRenderFunction;
-  record?: HtmlRenderFunction;
-  union?: HtmlRenderFunction;
-  discriminatedUnion?: HtmlRenderFunction;
-  literal?: HtmlRenderFunction;
-  file?: HtmlRenderFunction;
-  unknown?: HtmlRenderFunction;
-}
-declare const RESOLVER_KEYS: readonly ["string", "number", "boolean", "enum", "object", "array", "record", "union", "discriminatedUnion", "literal", "file", "unknown"];
-type ResolverKey = (typeof RESOLVER_KEYS)[number];
-/**
- * Map a schema type to the resolver key that handles it.
- * `discriminatedUnion` → `union`. Unknown types → `unknown`.
- */
-declare function typeToKey(type: WalkedField["type"]): ResolverKey;
-/**
- * Look up the render function for a schema type in a ComponentResolver.
- */
-declare function getRenderFunction(type: WalkedField["type"], resolver: ComponentResolver): RenderFunction | undefined;
-/**
- * Look up the render function for a schema type in an HtmlResolver.
- */
-declare function getHtmlRenderFn(type: WalkedField["type"], resolver: HtmlResolver): HtmlRenderFunction | undefined;
-/**
- * Merge two ComponentResolvers — user values take priority, fallback fills gaps.
- */
-declare function mergeResolvers(user: ComponentResolver, fallback: ComponentResolver): ComponentResolver;
-/**
- * Merge two HtmlResolvers — user values take priority, fallback fills gaps.
- */
-declare function mergeHtmlResolvers(user: HtmlResolver, fallback: HtmlResolver): HtmlResolver;
-//#endregion
-//#region src/core/types.d.ts
-/**
- * Core types for schema-components.
- *
- * These types define the vocabulary shared between the schema walker,
- * component resolver, and React components.
- */
-/** A raw JSON object (JSON Schema or OpenAPI document). */
-type JsonObject = Record<string, unknown>;
-/**
- * Metadata attached to schemas via `.meta()` or passed as props to
- * `<SchemaComponent>`. Every field is also available as a top-level
- * prop on `<SchemaComponent>` (with TypeScript-enforced exclusivity
- * between prop and `meta`).
- */
-interface SchemaMeta {
-  readOnly?: boolean;
-  writeOnly?: boolean;
-  description?: string;
-  title?: string;
-  deprecated?: boolean;
-  /** Component hint — resolved before theme adapter. */
-  component?: string;
-  /** Sort order for object fields. Lower values render first. */
-  order?: number;
-  /** Arbitrary UI hints passed through to theme adapters. */
-  [key: string]: unknown;
-}
-type Editability = "presentation" | "input" | "editable";
-/**
- * Resolved editability state for a single field.
- *
- * Priority (highest wins):
- * 1. Property-level readOnly → presentation
- * 2. Property-level writeOnly → input
- * 3. Component-level readOnly → presentation
- * 4. Component-level writeOnly → input
- * 5. Schema root readOnly → presentation
- * 6. Schema root writeOnly → input
- * 7. Neither → editable
- */
-declare function resolveEditability(propertyMeta: SchemaMeta | undefined, componentMeta: SchemaMeta | undefined, rootMeta: SchemaMeta | undefined): Editability;
-/**
- * Recursive mapped type that mirrors a schema's shape for per-field
- * overrides. Each leaf accepts schema meta overrides and an optional
- * per-field validation error callback. Objects recurse and also accept
- * their own overrides.
- */
-type FieldOverrides<T> = { [K in keyof T]?: T[K] extends object ? FieldOverrides<T[K]> & FieldOverride : FieldOverride };
-/**
- * Per-field override. Extends SchemaMeta with rendering controls
- * and a per-field validation error callback.
- */
-type FieldOverride = Partial<SchemaMeta> & {
-  /** Called with the ZodError when this field fails validation. */onValidationError?: (error: unknown) => void; /** Hide this field when false. Defaults to true (visible). */
-  visible?: boolean;
-};
-type SchemaType = "string" | "number" | "boolean" | "null" | "enum" | "literal" | "object" | "array" | "record" | "union" | "discriminatedUnion" | "optional" | "nullable" | "default" | "readonly" | "pipe" | "lazy" | "file" | "unknown";
-interface WalkedField {
-  type: SchemaType;
-  editability: Editability;
-  meta: SchemaMeta;
-  /** For objects: map of field name → WalkedField. */
-  fields?: Record<string, WalkedField>;
-  /** For arrays: the element schema. */
-  element?: WalkedField;
-  /** For enums: the allowed values. */
-  enumValues?: string[];
-  /** For unions/discriminated unions: the options. */
-  options?: WalkedField[];
-  discriminator?: string;
-  /** For records: key and value schemas. */
-  keyType?: WalkedField;
-  valueType?: WalkedField;
-  /** For literals: the literal value(s). */
-  literalValues?: (string | number | boolean | null)[];
-  /** Whether the field is optional. */
-  isOptional?: boolean;
-  /** Whether the field is nullable. */
-  isNullable?: boolean;
-  /** Default value if present on the schema. */
-  defaultValue?: unknown;
-  /** Constraints from Zod checks (min, max, pattern, etc.). */
-  constraints: FieldConstraints;
-}
-interface FieldConstraints {
-  minLength?: number;
-  maxLength?: number;
-  minimum?: number;
-  maximum?: number;
-  pattern?: string;
-  format?: string;
-  mimeTypes?: string[];
-  minItems?: number;
-  maxItems?: number;
-}
-/**
- * Maps a JSON Schema structure to a TypeScript type.
- * Works with `as const` literals — provides full autocomplete for `fields`.
- */
-type FromJSONSchema<S> = S extends {
-  type: "string";
-} ? string : S extends {
-  type: "number" | "integer";
-} ? number : S extends {
-  type: "boolean";
-} ? boolean : S extends {
-  type: "null";
-} ? null : S extends {
-  type: "array";
-  items: infer I;
-} ? FromJSONSchema<I>[] : S extends {
-  type: "object";
-  properties: infer P;
-  required?: infer R;
-} ? { [K in keyof P]: K extends R ? FromJSONSchema<P[K]> : FromJSONSchema<P[K]> | undefined } : unknown;
-/**
- * Resolves an OpenAPI `ref` string to its JSON Schema, then parses it.
- */
-type ResolveOpenAPIRef<Spec extends Record<string, unknown>, Ref extends string> = Ref extends `#/components/schemas/${infer Name}` ? Spec["components"] extends Record<string, unknown> ? Spec["components"]["schemas"] extends Record<string, unknown> ? Name extends keyof Spec["components"]["schemas"] ? FromJSONSchema<Spec["components"]["schemas"][Name]> : unknown : unknown : unknown : Ref extends `${string}/${string}` ? unknown : unknown;
-/** Navigate to a path item in an OpenAPI document. */
-type PathItemOf<Doc, Path extends string> = Doc extends {
-  paths: Record<string, unknown>;
-} ? Path extends keyof Doc["paths"] ? Doc["paths"][Path] : unknown : unknown;
-/** Navigate to an operation within a path item. */
-type OperationOf<PathItem, Method extends string> = PathItem extends Record<string, unknown> ? Method extends keyof PathItem ? PathItem[Method] : unknown : unknown;
-/** Extract the schema from request body content. */
-type RequestBodySchemaOf<Op> = Op extends {
-  requestBody: {
-    content: {
-      "application/json": {
-        schema: infer S;
-      };
-    };
-  };
-} ? S : Op extends {
-  requestBody: {
-    content: Record<string, {
-      schema: infer S;
-    }>;
-  };
-} ? S : unknown;
-/** Extract the schema from response content. */
-type ResponseSchemaOf<Op, Status extends string> = Op extends {
-  responses: Record<string, unknown>;
-} ? Status extends keyof Op["responses"] ? Op["responses"][Status] extends {
-  content: {
-    "application/json": {
-      schema: infer S;
-    };
-  };
-} ? S : Op["responses"][Status] extends {
-  content: Record<string, {
-    schema: infer S;
-  }>;
-} ? S : unknown : unknown : unknown;
-/** Resolve a schema that may be a $ref pointer. */
-type ResolveMaybeRef<Doc, S> = S extends {
-  $ref: infer R extends string;
-} ? ResolveOpenAPIRef<Doc & Record<string, unknown>, R> : S extends Record<string, unknown> ? FromJSONSchema<S> : unknown;
-/** Extract parameter names from an operation. */
-type ParameterNamesOf<Doc, Path extends string, Method extends string> = OperationOf<PathItemOf<Doc, Path>, Method> extends {
-  parameters: readonly unknown[];
-} ? OperationOf<PathItemOf<Doc, Path>, Method>["parameters"][number] extends {
-  name: infer N;
-} ? N extends string ? N : never : never : never;
-/**
- * Infer the TypeScript type of an OpenAPI operation's request body.
- */
-type OpenAPIRequestBodyType<Doc, Path extends string, Method extends string> = ResolveMaybeRef<Doc, RequestBodySchemaOf<OperationOf<PathItemOf<Doc, Path>, Method>>>;
-/**
- * Infer the TypeScript type of an OpenAPI operation's response.
- */
-type OpenAPIResponseType<Doc, Path extends string, Method extends string, Status extends string> = ResolveMaybeRef<Doc, ResponseSchemaOf<OperationOf<PathItemOf<Doc, Path>, Method>, Status>>;
-/**
- * Infer the fields prop type for ApiRequestBody.
- * Falls back to Record<string, FieldOverride> for runtime documents.
- */
-type InferRequestBodyFields<Doc, Path extends string, Method extends string> = unknown extends OpenAPIRequestBodyType<Doc, Path, Method> ? Record<string, FieldOverride> : FieldOverrides<OpenAPIRequestBodyType<Doc, Path, Method>>;
-/**
- * Infer the fields prop type for ApiResponse.
- * Falls back to Record<string, FieldOverride> for runtime documents.
- */
-type InferResponseFields<Doc, Path extends string, Method extends string, Status extends string> = unknown extends OpenAPIResponseType<Doc, Path, Method, Status> ? Record<string, FieldOverride> : FieldOverrides<OpenAPIResponseType<Doc, Path, Method, Status>>;
-/**
- * Infer the overrides prop type for ApiParameters.
- * Falls back to Record<string, FieldOverride> for runtime documents.
- */
-type InferParameterOverrides<Doc, Path extends string, Method extends string> = string extends ParameterNamesOf<Doc, Path, Method> ? Record<string, FieldOverride> : Partial<Record<ParameterNamesOf<Doc, Path, Method>, FieldOverride>>;
-/**
- * Check if T is a "narrow" type (not wide like object, Record, or unknown).
- * Used to determine if we can enumerate keys for path inference.
- */
-type IsNarrowObject<T> = T extends string | number | boolean | null | undefined | unknown[] ? false : T extends object ? Record<string, never> extends T ? false : true : false;
-/**
- * Extract all valid dot-separated paths from an object type.
- * Produces paths like "name" | "address.city" | "address.postcode".
- * Stops at leaf types (string, number, boolean, null) and arrays.
- * Returns `string` for wide types (object, Record, unknown).
- * Handles optional/nullable fields by unwrapping T | undefined.
- */
-type PathOfType<T, Prefix extends string = ""> = IsNarrowObject<T> extends true ? { [K in keyof T & string]: T[K] extends string | number | boolean | null | undefined ? `${Prefix}${K}` : T[K] extends unknown[] ? `${Prefix}${K}` : T[K] extends object | undefined ? PathOfType<Exclude<T[K], undefined>, `${Prefix}${K}.`> | `${Prefix}${K}` : `${Prefix}${K}` }[keyof T & string] : string;
-/**
- * Extract the type at a given dot-separated path.
- * PathOfType<T> produces valid paths; TypeAtPath resolves the leaf type.
- */
-type TypeAtPath<T, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? TypeAtPath<T[Key], Rest> : unknown : P extends keyof T ? T[P] : unknown;
-//#endregion
-export { mergeResolvers as A, HtmlResolver as C, getHtmlRenderFn as D, RenderProps as E, getRenderFunction as O, HtmlRenderProps as S, RenderFunction as T, WalkedField as _, FromJSONSchema as a, ComponentResolver as b, InferResponseFields as c, OpenAPIResponseType as d, PathOfType as f, TypeAtPath as g, SchemaType as h, FieldOverrides as i, typeToKey as j, mergeHtmlResolvers as k, JsonObject as l, SchemaMeta as m, FieldConstraints as n, InferParameterOverrides as o, ResolveOpenAPIRef as p, FieldOverride as r, InferRequestBodyFields as s, Editability as t, OpenAPIRequestBodyType as u, resolveEditability as v, RESOLVER_KEYS as w, HtmlRenderFunction as x, BaseFieldProps as y };