schema-components 2.0.2 → 2.1.0

package/dist/solid/types.d.mts

@@ -0,0 +1,90 @@
+import { j as WalkedField } from "../types-BBQaEPfE.mjs";
+import { l as RenderFunction, n as BaseFieldProps, t as AllConstraints } from "../renderer-ab9E52Bp.mjs";
+import { JSX } from "solid-js";
+
+//#region src/solid/types.d.ts
+/**
+ * Per-field props handed to a Solid render function.
+ *
+ * Mirrors React's `RenderProps` shape (the contract is identical at the
+ * data layer) but the `renderChild` return type is Solid's `JSX.Element`
+ * rather than React's `ReactNode`. The walker, path threading,
+ * constraint extraction, and union heuristics are all shared with the
+ * React adapter.
+ */
+interface SolidRenderProps 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 Solid resolver and rendering context are already
+   * wired in.
+   *
+   * @param tree - The walked field tree for the child.
+   * @param value - The child's current value.
+   * @param onChange - Callback receiving the child's next value.
+   * @param pathSuffix - Path segment from the parent (e.g. `"city"`,
+   *   `"[0]"`). Joined to the parent's path with a dot, or
+   *   substituted when the parent acts as a transparent wrapper
+   *   (union options). Required for every container — without it
+   *   children inherit no path and `fieldDomId()` returns the bare
+   *   prefix.
+   */
+  renderChild: (tree: WalkedField, value: unknown, onChange: (v: unknown) => void, pathSuffix?: string) => JSX.Element;
+}
+/**
+ * Signature for a Solid render function attached to a
+ * {@link SolidComponentResolver}. Specialises the generic
+ * {@link RenderFunction} from `core/renderer.ts` with Solid's `JSX.Element`
+ * output and the Solid-flavoured {@link SolidRenderProps} props.
+ *
+ * The compile-time relationship
+ *
+ * ```ts
+ * type Check = SolidRenderFunction extends RenderFunction<JSX.Element, SolidRenderProps>
+ *     ? true
+ *     : false; // → true
+ * ```
+ *
+ * holds by construction — the Solid renderer plugs into the generic
+ * core contract without any per-framework escape hatch.
+ */
+type SolidRenderFunction = RenderFunction<JSX.Element, SolidRenderProps>;
+/**
+ * Theme adapter — maps every schema field type to its Solid renderer.
+ * Unset keys fall back to the headless resolver (see
+ * `solid/headless.ts`). Pass to `<SchemaProvider resolver={...}>` to
+ * drive every schema-driven render with a specific theme.
+ *
+ * Structurally mirrors React's `ComponentResolver` from
+ * `core/renderer.ts` — Solid and React share the renderer key matrix
+ * because both consume the same `WalkedField` discriminated union.
+ */
+interface SolidComponentResolver {
+  string?: SolidRenderFunction;
+  number?: SolidRenderFunction;
+  boolean?: SolidRenderFunction;
+  null?: SolidRenderFunction;
+  enum?: SolidRenderFunction;
+  object?: SolidRenderFunction;
+  array?: SolidRenderFunction;
+  tuple?: SolidRenderFunction;
+  record?: SolidRenderFunction;
+  union?: SolidRenderFunction;
+  discriminatedUnion?: SolidRenderFunction;
+  conditional?: SolidRenderFunction;
+  negation?: SolidRenderFunction;
+  literal?: SolidRenderFunction;
+  file?: SolidRenderFunction;
+  never?: SolidRenderFunction;
+  unknown?: SolidRenderFunction;
+}
+/**
+ * Widget map for Solid — maps `.meta({ component: <name> })` hints to
+ * per-instance render functions. Identical contract to the React widget
+ * map; only the per-frame element type differs.
+ */
+type SolidWidgetMap = ReadonlyMap<string, SolidRenderFunction>;
+//#endregion
+export { type AllConstraints, SolidComponentResolver, SolidRenderFunction, SolidRenderProps, SolidWidgetMap };

package/dist/solid/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/solid/widget.d.mts

@@ -0,0 +1,29 @@
+import { SolidRenderFunction } from "./types.mjs";
+
+//#region src/solid/widget.d.ts
+/**
+ * Register a Solid widget globally. The widget is resolved when a schema
+ * field has `.meta({ component: <name> })`.
+ *
+ * For scoped registration prefer the `widgets` prop on
+ * `<SchemaComponent>` (instance-level) or `<SchemaProvider>`
+ * (context-level).
+ */
+declare function registerSolidWidget(name: string, render: SolidRenderFunction): void;
+/**
+ * Look up a globally registered Solid widget by name. Returns
+ * `undefined` when nothing is registered for the supplied name.
+ */
+declare function lookupGlobalSolidWidget(name: string): SolidRenderFunction | undefined;
+/**
+ * Clear every globally registered Solid widget. Intended for test
+ * isolation — `registerSolidWidget` writes to module-level state and
+ * that state otherwise leaks across test cases, making the test suite
+ * order-dependent. Tests should call this from a `beforeEach` or
+ * `afterEach` hook.
+ *
+ * @internal
+ */
+declare function __clearGlobalSolidWidgets(): void;
+//#endregion
+export { __clearGlobalSolidWidgets, lookupGlobalSolidWidget, registerSolidWidget };

package/dist/solid/widget.mjs

@@ -0,0 +1,35 @@
+//#region src/solid/widget.ts
+/** Global widget registry — app-wide Solid widget defaults. */
+const globalSolidWidgets = /* @__PURE__ */ new Map();
+/**
+* Register a Solid widget globally. The widget is resolved when a schema
+* field has `.meta({ component: <name> })`.
+*
+* For scoped registration prefer the `widgets` prop on
+* `<SchemaComponent>` (instance-level) or `<SchemaProvider>`
+* (context-level).
+*/
+function registerSolidWidget(name, render) {
+	globalSolidWidgets.set(name, render);
+}
+/**
+* Look up a globally registered Solid widget by name. Returns
+* `undefined` when nothing is registered for the supplied name.
+*/
+function lookupGlobalSolidWidget(name) {
+	return globalSolidWidgets.get(name);
+}
+/**
+* Clear every globally registered Solid widget. Intended for test
+* isolation — `registerSolidWidget` writes to module-level state and
+* that state otherwise leaks across test cases, making the test suite
+* order-dependent. Tests should call this from a `beforeEach` or
+* `afterEach` hook.
+*
+* @internal
+*/
+function __clearGlobalSolidWidgets() {
+	globalSolidWidgets.clear();
+}
+//#endregion
+export { __clearGlobalSolidWidgets, lookupGlobalSolidWidget, registerSolidWidget };

package/dist/themes/mantine.d.mts

@@ -1,4 +1,4 @@
-import { ComponentResolver } from "../core/renderer.mjs";
+import { i as ComponentResolver } from "../renderer-ab9E52Bp.mjs";
 import { ElementType } from "react";
 
 //#region src/themes/mantine.d.ts

package/dist/themes/mui.d.mts

@@ -1,4 +1,4 @@
-import { ComponentResolver } from "../core/renderer.mjs";
+import { i as ComponentResolver } from "../renderer-ab9E52Bp.mjs";
 import { ElementType } from "react";
 
 //#region src/themes/mui.d.ts

package/dist/themes/radix.d.mts

@@ -1,4 +1,4 @@
-import { ComponentResolver } from "../core/renderer.mjs";
+import { i as ComponentResolver } from "../renderer-ab9E52Bp.mjs";
 import { ElementType } from "react";
 
 //#region src/themes/radix.d.ts

package/dist/themes/shadcn.d.mts

@@ -1,4 +1,4 @@
-import { ComponentResolver } from "../core/renderer.mjs";
+import { i as ComponentResolver } from "../renderer-ab9E52Bp.mjs";
 
 //#region src/themes/shadcn.d.ts
 /**