schema-components 0.0.0 → 1.1.0

package/dist/themes/shadcn.mjs

@@ -0,0 +1,166 @@
+import { toRecord } from "../core/guards.mjs";
+import { headlessResolver, toReactNode } from "../react/headless.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/themes/shadcn.tsx
+function isString(value) {
+	return typeof value === "string";
+}
+function buildClassNames(...classes) {
+	return classes.filter(isString).join(" ");
+}
+function renderStringInput(props) {
+	const strValue = typeof props.value === "string" ? props.value : "";
+	const className = buildClassNames("flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors", "file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground", "placeholder:text-muted-foreground", "focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring", "disabled:cursor-not-allowed disabled:opacity-50");
+	if (props.readOnly) return /* @__PURE__ */ jsx("span", {
+		className: "text-sm",
+		children: strValue || "—"
+	});
+	if (props.writeOnly) return /* @__PURE__ */ jsx("input", {
+		type: props.constraints.format === "email" ? "email" : "text",
+		className,
+		placeholder: typeof props.meta.description === "string" ? props.meta.description : void 0,
+		value: "",
+		onChange: (e) => {
+			props.onChange(e.target.value);
+		}
+	});
+	return /* @__PURE__ */ jsx("input", {
+		type: props.constraints.format === "email" ? "email" : "text",
+		className,
+		value: strValue,
+		onChange: (e) => {
+			props.onChange(e.target.value);
+		},
+		placeholder: typeof props.meta.description === "string" ? props.meta.description : void 0,
+		minLength: props.constraints.minLength,
+		maxLength: props.constraints.maxLength
+	});
+}
+function renderNumberInput(props) {
+	const className = buildClassNames("flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-sm shadow-sm transition-colors", "placeholder:text-muted-foreground", "focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring", "disabled:cursor-not-allowed disabled:opacity-50");
+	if (props.readOnly) {
+		if (typeof props.value !== "number") return /* @__PURE__ */ jsx("span", {
+			className: "text-sm",
+			children: "—"
+		});
+		return /* @__PURE__ */ jsx("span", {
+			className: "text-sm",
+			children: props.value.toLocaleString()
+		});
+	}
+	return /* @__PURE__ */ jsx("input", {
+		type: "number",
+		className,
+		value: typeof props.value === "number" ? props.value : "",
+		onChange: (e) => {
+			props.onChange(Number(e.target.value));
+		},
+		min: props.constraints.minimum,
+		max: props.constraints.maximum
+	});
+}
+function renderBooleanInput(props) {
+	const className = buildClassNames("h-4 w-4 rounded border border-primary shadow", "focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring", "disabled:cursor-not-allowed disabled:opacity-50");
+	if (props.readOnly) {
+		if (typeof props.value !== "boolean") return /* @__PURE__ */ jsx("span", {
+			className: "text-sm",
+			children: "—"
+		});
+		return /* @__PURE__ */ jsx("span", {
+			className: "text-sm",
+			children: props.value ? "Yes" : "No"
+		});
+	}
+	return /* @__PURE__ */ jsx("input", {
+		type: "checkbox",
+		className,
+		checked: props.value === true,
+		onChange: (e) => {
+			props.onChange(e.target.checked);
+		}
+	});
+}
+function renderObjectContainer(props) {
+	const fields = props.fields;
+	if (fields === void 0) return null;
+	const obj = typeof props.value === "object" && props.value !== null && !Array.isArray(props.value) ? props.value : {};
+	return /* @__PURE__ */ jsxs("div", {
+		className: "space-y-4",
+		children: [typeof props.meta.description === "string" && /* @__PURE__ */ jsx("h3", {
+			className: "text-lg font-medium",
+			children: props.meta.description
+		}), Object.entries(fields).map(([key, field]) => {
+			const childValue = toRecord(obj)[key];
+			const childOnChange = (v) => {
+				const updated = {};
+				for (const [k, val] of Object.entries(obj)) updated[k] = val;
+				updated[key] = v;
+				props.onChange(updated);
+			};
+			return /* @__PURE__ */ jsxs("div", {
+				className: "space-y-1",
+				children: [/* @__PURE__ */ jsx("label", {
+					className: "text-sm font-medium leading-none",
+					children: field.meta.description ?? key
+				}), toReactNode(props.renderChild(field, childValue, childOnChange))]
+			}, key);
+		})]
+	});
+}
+function renderArrayContainer(props) {
+	const arr = Array.isArray(props.value) ? props.value : [];
+	const element = props.element;
+	if (element === void 0) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: "space-y-2",
+		children: arr.map((item, i) => {
+			const childOnChange = (v) => {
+				const next = arr.slice();
+				next[i] = v;
+				props.onChange(next);
+			};
+			return /* @__PURE__ */ jsx("div", { children: toReactNode(props.renderChild(element, item, childOnChange)) }, String(i));
+		})
+	});
+}
+function renderEnumInput(props) {
+	const className = buildClassNames("flex h-9 w-full items-center justify-between rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm", "focus:outline-none focus:ring-1 focus:ring-ring", "disabled:cursor-not-allowed disabled:opacity-50");
+	const enumValue = typeof props.value === "string" ? props.value : "";
+	if (props.readOnly) return /* @__PURE__ */ jsx("span", {
+		className: "text-sm",
+		children: enumValue || "—"
+	});
+	return /* @__PURE__ */ jsxs("select", {
+		className,
+		value: props.writeOnly ? "" : enumValue,
+		onChange: (e) => {
+			props.onChange(e.target.value);
+		},
+		children: [/* @__PURE__ */ jsx("option", {
+			value: "",
+			children: "Select…"
+		}), props.enumValues?.map((v) => /* @__PURE__ */ jsx("option", {
+			value: v,
+			children: v
+		}, v))]
+	});
+}
+function buildResolver() {
+	const resolver = {
+		string: renderStringInput,
+		number: renderNumberInput,
+		boolean: renderBooleanInput,
+		enum: renderEnumInput,
+		object: renderObjectContainer,
+		array: renderArrayContainer
+	};
+	if (headlessResolver.literal !== void 0) resolver.literal = headlessResolver.literal;
+	if (headlessResolver.union !== void 0) resolver.union = headlessResolver.union;
+	if (headlessResolver.record !== void 0) resolver.record = headlessResolver.record;
+	if (headlessResolver.file !== void 0) resolver.file = headlessResolver.file;
+	if (headlessResolver.unknown !== void 0) resolver.unknown = headlessResolver.unknown;
+	return resolver;
+}
+const shadcnResolver = buildResolver();
+//#endregion
+export { shadcnResolver };

package/dist/types-BU0ETFHk.d.mts

@@ -0,0 +1,326 @@
+//#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;
+  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;
+  literal?: HtmlRenderFunction;
+  file?: HtmlRenderFunction;
+  unknown?: HtmlRenderFunction;
+}
+declare const RESOLVER_KEYS: readonly ["string", "number", "boolean", "enum", "object", "array", "record", "union", "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;
+  /** 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
+ * meta overrides. Each leaf is `Partial<SchemaMeta>`, objects recurse
+ * and also accept their own `SchemaMeta`.
+ */
+type FieldOverrides<T> = { [K in keyof T]?: T[K] extends object ? FieldOverrides<T[K]> & Partial<SchemaMeta> : Partial<SchemaMeta> };
+/**
+ * Fallback type for runtime schemas (no compile-time shape).
+ */
+type FieldOverride = Partial<SchemaMeta>;
+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 };

package/package.json

@@ -1,5 +1,115 @@
 {
-  "name": "schema-components",
-  "version": "0.0.0",
-  "private": false
+    "name": "schema-components",
+    "version": "1.1.0",
+    "description": "React components that render UI from Zod schemas, JSON Schema, and OpenAPI documents",
+    "type": "module",
+    "main": "./dist/index.mjs",
+    "types": "./dist/index.d.mts",
+    "exports": {
+        "./styles.css": "./dist/html/styles.css",
+        "./core/*": {
+            "types": "./dist/core/*.d.mts",
+            "import": "./dist/core/*.mjs"
+        },
+        "./react/*": {
+            "types": "./dist/react/*.d.mts",
+            "import": "./dist/react/*.mjs"
+        },
+        "./openapi/*": {
+            "types": "./dist/openapi/*.d.mts",
+            "import": "./dist/openapi/*.mjs"
+        },
+        "./html/*": {
+            "types": "./dist/html/*.d.mts",
+            "import": "./dist/html/*.mjs"
+        },
+        "./themes/*": {
+            "types": "./dist/themes/*.d.mts",
+            "import": "./dist/themes/*.mjs"
+        }
+    },
+    "files": [
+        "dist",
+        "LICENSE",
+        "README.md",
+        "CHANGELOG.md"
+    ],
+    "scripts": {
+        "build": "turbo run _build",
+        "_typecheck": "tsc --noEmit",
+        "_lint": "eslint --cache 'src/**/*.{ts,tsx}'",
+        "_lint:fix": "eslint --cache --fix 'src/**/*.{ts,tsx}'",
+        "_test": "node --test 'tests/**/*.unit.test.ts' 'tests/**/*.integration.test.ts'",
+        "_test:coverage": "node --test --experimental-test-coverage --test-coverage-lines=80 --test-coverage-branches=80 --test-coverage-functions=80 --test-coverage-include='src/**/*.ts' --test-coverage-include='src/**/*.tsx' 'tests/**/*.unit.test.ts' 'tests/**/*.integration.test.ts'",
+        "_build": "tsdown && cp src/html/styles.css dist/html/styles.css",
+        "typecheck": "turbo run _typecheck",
+        "lint": "turbo run _lint",
+        "lint:fix": "turbo run _lint:fix",
+        "test": "turbo run _test",
+        "test:coverage": "turbo run _test:coverage",
+        "check": "turbo run _check",
+        "validate": "turbo run _validate",
+        "storybook": "storybook dev --port 6006",
+        "build-storybook": "storybook build --output-dir storybook-static",
+        "release": "semantic-release",
+        "release:dry": "semantic-release --dry-run",
+        "prepare": "husky",
+        "prepublishOnly": "pnpm validate"
+    },
+    "keywords": [
+        "react",
+        "zod",
+        "json-schema",
+        "openapi",
+        "schema",
+        "form",
+        "components",
+        "headless",
+        "ui"
+    ],
+    "author": "Joseph Mearman",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Mearman/schema-components.git"
+    },
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "peerDependencies": {
+        "react": "^18.0.0 || ^19.0.0",
+        "zod": "^4.0.0"
+    },
+    "devDependencies": {
+        "@commitlint/cli": "20.5.3",
+        "@commitlint/config-conventional": "20.5.3",
+        "@eslint/js": "10.0.1",
+        "@semantic-release/changelog": "6.0.3",
+        "@semantic-release/git": "10.0.1",
+        "@semantic-release/github": "12.0.6",
+        "@storybook/react": "10.4.0",
+        "@storybook/react-vite": "10.4.0",
+        "@types/node": "25.6.0",
+        "@types/react": "19.2.14",
+        "conventional-changelog-conventionalcommits": "9.3.1",
+        "eslint": "10.3.0",
+        "eslint-config-prettier": "10.1.8",
+        "eslint-plugin-prettier": "5.5.5",
+        "husky": "9.1.7",
+        "lint-staged": "17.0.2",
+        "prettier": "3.8.3",
+        "react": "19.2.6",
+        "react-dom": "19.2.6",
+        "semantic-release": "25.0.3",
+        "storybook": "10.4.0",
+        "tsdown": "0.21.10",
+        "tslib": "2.8.1",
+        "turbo": "2.9.9",
+        "typescript": "6.0.3",
+        "typescript-eslint": "8.59.2",
+        "vite": "^8.0.12",
+        "zod": "4.4.3"
+    },
+    "packageManager": "pnpm@10.33.1"
 }