@nolwenture/formik-jsonschema-form 2.0.2 → 3.0.0-beta.1

package/dist/types/v3/raw/store/createStore.d.ts

@@ -0,0 +1,39 @@
+export type FormState = {
+    values: any;
+    errors: any;
+    touched: any;
+    isSubmitting: boolean;
+    submitCount: number;
+};
+export type ValidationSchemaLike = {
+    validate: (values: unknown, options?: object) => Promise<unknown>;
+};
+export type StoreOptions = {
+    initialValues?: unknown;
+    validationSchema?: ValidationSchemaLike;
+    onSubmit?: (values: any, store: Store) => unknown;
+    validateOnChange?: boolean;
+    validateOnBlur?: boolean;
+    /** Called after every validation run with its errors (the controller's `validate` event). */
+    onValidated?: (errors: any) => void;
+};
+export type Store = {
+    getState(): FormState;
+    /** Replaces parts of the state without validating (formik setErrors / setTouched / resetForm({ values })). */
+    setState(patch: Partial<FormState>): void;
+    subscribe(listener: (state: FormState) => void): () => void;
+    setValues(values: unknown, shouldValidate?: boolean): Promise<void>;
+    setFieldValue(path: string, value: unknown, shouldValidate?: boolean): Promise<void>;
+    setFieldTouched(path: string, touched?: boolean, shouldValidate?: boolean): Promise<void>;
+    setFieldError(path: string, message: string | undefined): void;
+    setSubmitting(submitting: boolean): void;
+    validateForm(values?: unknown): Promise<any>;
+    submitForm(): Promise<void>;
+};
+/** formik prepareDataForValidation: "" is undefined, nested objects and arrays included. */
+export declare const prepareForValidation: (values: any) => any;
+/** formik yupToFormErrors: the first message per path. */
+export declare const toFormErrors: (error: any) => any;
+/** formik setNestedObjectValues(values, true): the touched map after a submit attempt. */
+export declare const touchAll: (values: any, seen?: WeakSet<object>) => any;
+export declare const createStore: (options?: StoreOptions) => Store;

package/dist/types/v3/raw/styles/color.d.ts

@@ -0,0 +1,15 @@
+type Rgb = {
+    red: number;
+    green: number;
+    blue: number;
+    alpha?: number;
+};
+/** polished parseToRgb; undefined where polished throws. */
+export declare const parseToRgb: (color: string) => Rgb | undefined;
+export declare const lighten: (amount: number, color: string) => string | undefined;
+export declare const darken: (amount: number, color: string) => string | undefined;
+/** polished getLuminance (relative luminance, 3 decimals). */
+export declare const getLuminance: (color: string) => number | undefined;
+/** polished readableColor(color) with its defaults: "#000" on light colours, "#fff" on dark ones. */
+export declare const readableColor: (color: string) => string | undefined;
+export {};

package/dist/types/v3/raw/styles/colorNames.d.ts

@@ -0,0 +1 @@
+export declare const NAMED_COLORS: Readonly<Record<string, string>>;

package/dist/types/v3/raw/styles/defaultStyles.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_STYLES: string;

package/dist/types/v3/raw/styles/index.d.ts

@@ -0,0 +1,8 @@
+/** The default stylesheet (also `styles.css`): inline it before your own CSS, e.g. in PDF HTML. */
+export declare const getDefaultStyles: () => string;
+/** Form registry names -> their class (an alias gives the class its element carries). Frozen for 3.x. */
+export declare const fjsfClassNames: Readonly<Record<string, string>>;
+/** The same as selectors (`.fjsf-X`), what `${FormComponents.X}` interpolates. */
+export declare const fjsfSelectors: Readonly<Record<string, string>>;
+export { themeToCssVars, cssVarsToString } from "./themeToCssVars";
+export { varName, FOCUS_PROPERTIES, DERIVED_COLORS, DERIVED_URLS } from "./vars";

package/dist/types/v3/raw/styles/themeToCssVars.d.ts

@@ -0,0 +1,4 @@
+/** The --fjsf-* variables of a theme (set them on :root or on a form's container). */
+export declare const themeToCssVars: (theme: unknown) => Record<string, string>;
+/** The variables as one CSS rule, e.g. for a <style> element or the PDF HTML. */
+export declare const cssVarsToString: (vars: Record<string, string>, selector?: string) => string;

package/dist/types/v3/raw/styles/vars.d.ts

@@ -0,0 +1,43 @@
+/** `--fjsf-color-text-default` for theme.color.text.default (camelCase keys become kebab-case). */
+export declare const varName: (keys: readonly string[]) => string;
+/** A theme's `focus.*` value is a declaration list; styles.css applies these three properties of it. */
+export declare const FOCUS_PROPERTIES: readonly ["outline", "outline-offset", "box-shadow"];
+/** The derived colours: variable, polished function, amount and the theme path it reads. */
+export declare const DERIVED_COLORS: readonly [{
+    readonly name: "--fjsf-on-text";
+    readonly fn: "readableColor";
+    readonly path: readonly ["color", "text", "default"];
+}, {
+    readonly name: "--fjsf-on-input";
+    readonly fn: "readableColor";
+    readonly path: readonly ["color", "background", "input"];
+}, {
+    readonly name: "--fjsf-on-intent-none";
+    readonly fn: "readableColor";
+    readonly path: readonly ["color", "intent", "default", "none"];
+}, {
+    readonly name: "--fjsf-on-neutral-500";
+    readonly fn: "readableColor";
+    readonly path: readonly ["color", "palette", "neutral", "500"];
+}, {
+    readonly name: "--fjsf-border-muted";
+    readonly fn: "lighten";
+    readonly amount: 0.4;
+    readonly path: readonly ["color", "border", "default"];
+}, {
+    readonly name: "--fjsf-text-muted";
+    readonly fn: "lighten";
+    readonly amount: 0.4;
+    readonly path: readonly ["color", "text", "default"];
+}, {
+    readonly name: "--fjsf-primary-dark";
+    readonly fn: "darken";
+    readonly amount: 0.3;
+    readonly path: readonly ["color", "intent", "default", "primary"];
+}];
+/** 2.x encoded a theme colour into an SVG data URL (Form/styles/common.tsx:78,96, the select arrow): a variable holds the whole url(). */
+export declare const DERIVED_URLS: readonly [{
+    readonly name: "--fjsf-select-arrow";
+    readonly path: readonly ["color", "text", "default"];
+    readonly url: (color: string) => string;
+}];

package/dist/types/v3/raw/validation/arrays.d.ts

@@ -0,0 +1,16 @@
+import * as Yup from "yup";
+import type { Schema } from "../core/json";
+import type { IssueSink } from "../core/issues";
+import type { MessageFn } from "./messages";
+export type ArrayContext = {
+    /** Builds the Yup schema of one item (items count as required, as in 2.x). */
+    item: (schema: Schema) => Yup.ISchema<any>;
+    msg: MessageFn;
+    ui: any;
+    required: boolean;
+    sink: IssueSink;
+    path: string;
+};
+export declare const buildArraySchema: (schema: Schema, ctx: ArrayContext) => Yup.ISchema<any>;
+/** 2.x `type: array` + `anyOf` (multi-select): every value must be one of the consts. */
+export declare const buildAnyOfArraySchema: (schema: Schema, ctx: Omit<ArrayContext, "item" | "sink" | "path">) => Yup.ISchema<any>;

package/dist/types/v3/raw/validation/conditions.d.ts

@@ -0,0 +1,10 @@
+import type { Schema } from "../core/json";
+export type Condition = {
+    dependentKeys: string[];
+    conditionFn: (...values: any[]) => boolean;
+};
+export type ConditionalValidation = {
+    condition?: Condition;
+    schema: Schema;
+};
+export declare function getConditionalValidations(schema: Schema): ConditionalValidation[];

package/dist/types/v3/raw/validation/index.d.ts

@@ -0,0 +1,30 @@
+import * as Yup from "yup";
+import type { Definitions, Schema } from "../core/json";
+import type { IssueSink } from "../core/issues";
+import type { Condition } from "./conditions";
+import type { LocalizeType } from "./messages";
+import type { Translate } from "../i18n";
+import type { Trail } from "../core/trail";
+export type { LocalizeType };
+type ConditionsContext = {
+    condition: Condition;
+    yupSchema: Yup.ISchema<any>;
+};
+export type ValidationOptions = {
+    localize?: LocalizeType;
+    translate?: Translate;
+    definitions?: Schema | Definitions;
+    /** Root `$defs` (2019-09+), passed down like `definitions`. */
+    defs?: Definitions;
+    conditionsContext?: Record<string, ConditionsContext[]>;
+    condition?: Condition;
+    sink?: IssueSink;
+    /** `$ref`s being expanded eagerly above this level (cycle guard). */
+    refChain?: string[];
+    /** Internal: the object schemas being expanded above this level (cycle and depth guard, BUG-110). */
+    trail?: Trail;
+};
+export declare function createValidationSchema(schemas: {
+    schema: Schema;
+    uiSchema?: any;
+}, options?: ValidationOptions): Yup.ObjectSchema<any, Yup.AnyObject, any, "">;

package/dist/types/v3/raw/validation/keywords.d.ts

@@ -0,0 +1,10 @@
+import * as Yup from "yup";
+import type { Schema } from "../core/json";
+import type { IssueSink } from "../core/issues";
+import type { MessageFn } from "./messages";
+export declare const applyStringKeywords: (base: Yup.StringSchema, schema: Schema, ui: any, msg: MessageFn, sink: IssueSink, path: string) => Yup.StringSchema<string | undefined, Yup.AnyObject, undefined, "">;
+export declare const applyNumberKeywords: (base: Yup.NumberSchema, schema: Schema, ui: any, msg: MessageFn) => Yup.NumberSchema<number | undefined, Yup.AnyObject, undefined, "">;
+/** minItems / maxItems / uniqueItems (Q-VAL-6: deep equality instead of Set identity). */
+export declare const applyArrayKeywords: (base: any, schema: Schema, ui: any, msg: MessageFn) => any;
+/** enum / const (incl. `{ $data }`, Q-VAL-7 kept: last pointer segment) / not.const. */
+export declare const applyValueKeywords: (base: any, schema: Schema, ui: any, msg: MessageFn) => any;

package/dist/types/v3/raw/validation/messages.d.ts

@@ -0,0 +1,8 @@
+import type { Translate } from "../i18n";
+export type LocalizeType = (key: string, params?: Record<string, any>) => string;
+export type MessageOptions = {
+    localize?: LocalizeType;
+    translate?: Translate;
+};
+export declare const makeMessage: ({ localize, translate }: MessageOptions) => (keyword: string, fieldUiSchema?: any, params?: Record<string, any>) => string;
+export type MessageFn = ReturnType<typeof makeMessage>;

package/dist/types/v3/raw/validation/patterns.d.ts

@@ -0,0 +1,8 @@
+import type { IssueSink } from "../core/issues";
+/** Values longer than this are not run through a pattern (they fail it instead). */
+export declare const DEFAULT_PATTERN_INPUT_CAP = 10000;
+export declare const isUnsafePattern: (pattern: string) => boolean;
+/** A compiled pattern, or undefined when it is invalid or rejected (the keyword is skipped). */
+export declare const compilePattern: (pattern: unknown, sink: IssueSink, path?: string) => RegExp | undefined;
+/** Q-VAL-1 semantics with an input cap: over-long values never reach the regex. */
+export declare const testPattern: (regex: RegExp, value: unknown, cap: number) => boolean;

package/dist/types/v3/react/chain.d.ts

@@ -0,0 +1 @@
+export declare const ChainContext: import("react").Context<string[]>;

package/dist/types/v3/react/compat.d.ts

@@ -0,0 +1,4 @@
+/** 2.x SchemaField's schema type -> field name table. */
+export declare const COMPONENT_TYPES: Readonly<Record<string, string>>;
+/** 2.x FormView's outer wrapper (a styled div), as a compat primitive with its `fjsf-view-FormWrapper` class. */
+export declare const FormWrapper: import("react").ForwardRefExoticComponent<Omit<any, "ref"> & import("react").RefAttributes<HTMLDivElement>> & import("./selector").StyledSelector;

package/dist/types/v3/react/componentsProp.d.ts

@@ -0,0 +1,5 @@
+export declare const COMPONENTS_PROP_WARNING = "formik-jsonschema-form: the `components` prop is not supported in v3 and is ignored. Pass `slots` instead (each slot gets the library's component as `Default`); the fjsf-v3-codemod rewrites it.";
+/** Warns once per process when `components` is passed (not in production). */
+export declare const warnComponentsProp: (components: unknown) => void;
+/** Tests: warn again. */
+export declare const resetComponentsPropWarning: () => void;

package/dist/types/v3/react/defined.d.ts

@@ -0,0 +1 @@
+export declare const defined: <T>(map: Partial<Record<string, T>> | undefined) => Record<string, T>;

package/dist/types/v3/react/ejs/EJSField.d.ts

@@ -0,0 +1,14 @@
+import type { ViewField } from "../view/registry";
+/**
+ * The final HTML of the field, or `undefined` when nothing may be rendered. The template is NOT RUN unless the output can be
+ * sanitised: no window, or a window that cannot sanitise (a shim), reports `window` / `sanitizer` first. ejs-browser
+ * templates see Node's globals (SEC-SSR-2), so a server must never execute a tenant's template, and 2.x did (it ran it,
+ * then threw SANITIZER_UNAVAILABLE). A real DOM window in a server process still runs templates: only
+ * `setSanitizerWindow` without a global window stays disabled.
+ */
+export declare const renderTemplate: (template: unknown, scope: {
+    title: string;
+    description: string;
+    value: unknown;
+}, onIssue: (detail: string) => void) => string | undefined;
+export declare const EJSField: ViewField;

package/dist/types/v3/react/ejs/index.d.ts

@@ -0,0 +1 @@
+export { EJSField, renderTemplate } from "./EJSField";

package/dist/types/v3/react/form/components.d.ts

@@ -0,0 +1,3 @@
+export declare const FormComponents: Record<string, any>;
+/** registry.components: the defaults with the caller's slots; `SubmitButton` is the submit button (FormButton). */
+export declare const formCompatComponents: (slots?: Record<string, any>) => Record<string, any>;

package/dist/types/v3/react/form/fields.d.ts

@@ -0,0 +1,8 @@
+import type { ChildProps, FormBuildContext } from "../../raw/model/form";
+import type { FormField, FormFieldProps } from "./registry";
+/** The RAW build context of the current form: Formik state, registry, replaced fields, UI state. */
+export declare const useFormBuild: () => FormBuildContext;
+/** 2.x field props -> the RAW child props. */
+export declare const childProps: (p: FormFieldProps) => ChildProps;
+export declare const SchemaField: FormField;
+export declare const FormFields: Record<string, FormField>;

package/dist/types/v3/react/form/host.d.ts

@@ -0,0 +1,9 @@
+import type { FormikContextType } from "formik";
+import type { ReactNode } from "react";
+import type { VChild } from "../../raw/model/vnode";
+import type { ToReactEnv } from "../toReact";
+import type { FormRegistryContext, FormRuntime } from "./registry";
+export declare const formHost: (registry: FormRegistryContext, hole?: ReactNode, holes?: Record<string, ReactNode>) => ToReactEnv["host"];
+export declare const formBind: (runtime: FormRuntime, formik: FormikContextType<any> | undefined) => ToReactEnv["bind"];
+/** toReact with the current registry and runtime; holes are where React children go. */
+export declare const useFormRender: () => (node: VChild, hole?: ReactNode, holes?: Record<string, ReactNode>) => ReactNode;

package/dist/types/v3/react/form/registry.d.ts

@@ -0,0 +1,46 @@
+import type { ComponentType } from "react";
+import type { Definitions } from "../../raw/core/json";
+import type { IssueSink } from "../../raw/core/issues";
+import type { ControlEvent, FormAction, FormUiState } from "../../raw/model/form";
+export type FormFieldProps = {
+    name: string;
+    schema: any;
+    uiSchema?: any;
+    required?: boolean;
+    [key: string]: any;
+};
+export type FormField = ComponentType<FormFieldProps>;
+export type FormRegistryContext = {
+    fields: Record<string, FormField>;
+    templates: Record<string, ComponentType<any>>;
+    /** The deprecated compat map (CM-a): 2.x keys, React primitives, slots applied. */
+    components: Record<string, any>;
+    definitions: Definitions | undefined;
+    uiSchemaDefinitions: Record<string, any> | undefined;
+    formContext: Record<string, any>;
+    formLocalization?: Record<string, any>;
+    formOptions?: Record<string, any>;
+    useItemsAsAdditionalItems: boolean;
+    hideUnmarkedAdditionalProperties: boolean;
+    onAdditionalPropertyOrderChange?: (fieldName: string, oldOrder: string[], newOrder: string[]) => void;
+};
+export declare const FormRegistry: import("react").Context<FormRegistryContext>;
+export type FormRuntime = {
+    ui: FormUiState;
+    dispatch: (action: FormAction, event?: ControlEvent) => void;
+    /** Queues a values transform (defaults, pruning); all queued ones are applied as one setValues. */
+    settle: (transform: (values: unknown) => unknown) => void;
+    /** A ref for the active option of a searchable select: scrolls it into view when it changes (guarded). */
+    scrollActive?: (path: string, index: number) => (el: Element | null) => void;
+    /** Forgets the scrolled option of a searchable select (no option active). */
+    clearActive?: (path: string) => void;
+    /** Keeps AnyField types guessed on first render (only paths without a type yet). */
+    keepAnyTypes?: (guesses: Record<string, string>) => void;
+    /** Registers (or, with undefined, drops) the document keydown action of an open searchable select. */
+    onDocumentKey?: (path: string, action: FormAction | undefined) => void;
+    /** Q-SEL-1: the field container of a searchable select; only the instance holding focus reacts to the document key. */
+    keyTarget?: (path: string) => (el: Element | null) => void;
+    defs?: Definitions;
+    sink?: IssueSink;
+};
+export declare const FormRuntimeContext: import("react").Context<FormRuntime>;

package/dist/types/v3/react/form/root.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from "react";
+import type { IssueSink } from "../../raw/core/issues";
+import type { ComponentType } from "react";
+/** `T`: the form values (accepted for 2.x `FormProps<T>` users; values live in the surrounding Formik). */
+export type FormProps<T = any> = {
+    schema: any;
+    uiSchema?: any;
+    className?: string;
+    children?: ReactNode;
+    /** Field components by name: 2.x `Field` components work unchanged (C6); `undefined` entries are ignored. */
+    fields?: Partial<Record<string, ComponentType<any>>>;
+    templates?: Record<string, any>;
+    /** Replaces `components` (D3): each slot gets the library's `Default` for its key. */
+    slots?: Record<string, any>;
+    formContext?: Record<string, any>;
+    formOptions?: Record<string, any>;
+    formLocalization?: Record<string, any>;
+    /** A no-op since A11: the array normaliser treats a single `items` like this already (deprecated). */
+    useItemsAsAdditionalItems?: boolean;
+    hideUnmarkedAdditionalProperties?: boolean;
+    onAdditionalPropertyOrderChange?: (fieldName: string, oldOrder: string[], newOrder: string[]) => void;
+    hideSubmit?: boolean;
+    /** Receives issue codes (REF_CYCLE, KEY_REJECTED, PROP_REJECTED, ...). */
+    sink?: IssueSink;
+    /**
+     * @deprecated Removed in v3 (D3): use `slots`; each slot gets the library's component as `Default`.
+     * Typed `never` so a call that still passes it fails to compile; at runtime it is ignored with a warning.
+     */
+    components?: never;
+    [key: string]: unknown;
+};
+export declare const Form: (props: FormProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/v3/react/form/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { FormikContextType } from "formik";
+import type { FormRegistryContext, FormRuntime } from "./registry";
+export declare const useFormRuntime: (formik: FormikContextType<any> | undefined, registry: FormRegistryContext, root: Pick<FormRuntime, "defs" | "sink">) => FormRuntime;

package/dist/types/v3/react/form/templates.d.ts

@@ -0,0 +1 @@
+export declare const FormTemplates: Record<"ArrayFieldTemplate" | "CollapsibleObjectFieldTemplate" | "FieldTemplate" | "ObjectFieldTemplate", any> & Record<string, any>;

package/dist/types/v3/react/form/upload.d.ts

@@ -0,0 +1,3 @@
+import type { FormFieldProps } from "./registry";
+export declare const FileUploadField: (props: FormFieldProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FilesUploadField: (props: FormFieldProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/v3/react/form/uploadContexts.d.ts

@@ -0,0 +1,34 @@
+export type UploadProgressEvent = {
+    loaded: number;
+    total?: number | null;
+};
+export type FileUploadContextType<T> = {
+    uploadFile: (x: {
+        data: FormData;
+        onUploadProgress?: (progressEvent: UploadProgressEvent) => void;
+    }) => Promise<T>;
+    fetchFile: (value: T) => Promise<{
+        name: string;
+    }>;
+    removeFile: (fileName: string) => Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+};
+export type FilesUploadContextType<T> = {
+    uploadFiles: (x: {
+        files: {
+            data: File;
+            progressId: string;
+        }[];
+        onUploadProgress?: (e: UploadProgressEvent, progressId: string) => void;
+    }) => Promise<Array<T & {
+        progressId: string;
+    }>>;
+    removeFile: (file: T) => Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+};
+export declare const FileUploadContext: import("react").Context<FileUploadContextType<any>>;
+export declare const FilesUploadContext: import("react").Context<FilesUploadContextType<any>>;

package/dist/types/v3/react/form/useSetDefault.d.ts

@@ -0,0 +1,5 @@
+export declare const useSetDefault: (props: {
+    name?: string;
+    schema?: any;
+    forceDefaultValue?: boolean;
+}) => void;

package/dist/types/v3/react/hostCore.d.ts

@@ -0,0 +1,24 @@
+import type { ReactNode } from "react";
+import type { TemplateHost } from "../raw/model/host";
+import type { ToReactEnv } from "./toReact";
+type Registry = {
+    fields: Record<string, any>;
+    templates: Record<string, any>;
+    components: Record<string, any>;
+};
+export type HostDefaults<R extends Registry> = {
+    components: Record<string, any>;
+    templates: Record<string, any>;
+    /** The classes the default element of a component chain carries (not passed to an override). */
+    defaultClasses: (names: string[]) => string[];
+    /** A replaced template's `children` (2.x shape per template). */
+    children: (registry: R, host: TemplateHost, env: ToReactEnv) => ReactNode;
+};
+/** Own entries only: a uiSchema naming `constructor` or `toString` finds nothing (SEC-6, SEC-SSR-3). */
+export declare const own: (map: Record<string, any> | undefined, name: string | undefined) => any;
+/** 2.x `components.A ?? components.B`. */
+export declare const lookup: (map: Record<string, any>, names: string[]) => any;
+/** Continues the $ref chain below a React boundary. */
+export declare const chained: (chain: string[] | undefined, element: ReactNode) => string | number | boolean | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | import("react").FunctionComponentElement<import("react").ProviderProps<string[]>> | null | undefined;
+export declare const createHost: <R extends Registry>(defaults: HostDefaults<R>) => (registry: R, hole?: ReactNode, holes?: Record<string, ReactNode>) => ToReactEnv["host"];
+export {};

package/dist/types/v3/react/index.d.ts

@@ -0,0 +1,23 @@
+export { FormView } from "./view/root";
+export type { FormViewProps } from "./view/root";
+export { FormViewRegistry } from "./view/registry";
+export type { FormViewRegistryContext, ViewField, ViewFieldProps } from "./view/registry";
+export { FormViewFields, SchemaField } from "./view/fields";
+export { FormViewTemplates } from "./view/templates";
+export type { ViewArrayTemplateProps, ViewTemplateProps } from "./view/templates";
+export { FormViewComponents, compatComponents } from "./view/components";
+export type { ViewSlot, ViewSlots } from "./view/components";
+export { reactProps, toReact } from "./toReact";
+export type { ToReactEnv } from "./toReact";
+export { Form } from "./form/root";
+export type { FormProps } from "./form/root";
+export { FormRegistry } from "./form/registry";
+export type { FormField, FormFieldProps, FormRegistryContext } from "./form/registry";
+export { FormFields, SchemaField as FormSchemaField } from "./form/fields";
+export { FormTemplates } from "./form/templates";
+export { FormComponents, formCompatComponents } from "./form/components";
+/** @deprecated 3.x: defaults are applied per node appearance (§2.7a); kept as a wrapper. */
+export { useSetDefault } from "./form/useSetDefault";
+export { FileUploadContext, FilesUploadContext } from "./form/uploadContexts";
+export type { FileUploadContextType, FilesUploadContextType, UploadProgressEvent } from "./form/uploadContexts";
+export { cssVarsToString, fjsfClassNames, fjsfSelectors, getDefaultStyles, themeToCssVars } from "../raw/styles";

package/dist/types/v3/react/selector.d.ts

@@ -0,0 +1,10 @@
+export type StyledSelector = {
+    styledComponentId: string;
+    foldedComponentIds: string;
+    target: string;
+    attrs: unknown[];
+    shouldForwardProp: (prop: string) => boolean;
+    toString: () => string;
+};
+/** `classes`: the element's chain, base first; the last one is the component's own class. */
+export declare const asStyledSelector: <C extends object>(component: C, tag: string, classes: readonly string[]) => C & StyledSelector;

package/dist/types/v3/react/slots.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentType } from "react";
+export type Slot = ComponentType<any>;
+export type Slots = Partial<Record<string, Slot>>;
+export declare const withSlots: (defaults: Record<string, any>, fallback: Record<string, string>, slots?: Slots, aliases?: Record<string, string>) => Record<string, any>;

package/dist/types/v3/react/toReact.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+import type { VChild, VNode } from "../raw/model/vnode";
+export type ToReactEnv = {
+    /** Renders a host-marked node; `native` renders its default markup. */
+    host?: (node: VNode, native: () => ReactNode, env: ToReactEnv) => ReactNode;
+    /** Turns a node's `on` descriptors into React props (handlers, controlled value). */
+    bind?: (node: VNode, props: Record<string, unknown>) => Record<string, unknown>;
+};
+export declare const reactProps: (attrs: VNode["attrs"]) => Record<string, unknown>;
+export declare const toReact: (child: VChild, env?: ToReactEnv) => ReactNode;

package/dist/types/v3/react/view/components.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentType } from "react";
+export declare const FormViewComponents: Record<string, any>;
+export type ViewSlotName = Exclude<keyof typeof FormViewComponents & string, "getComponents">;
+/** A slot: the caller's component, rendered with the library's `Default` for that key. */
+export type ViewSlot = ComponentType<any>;
+export type ViewSlots = Partial<Record<string, ViewSlot>>;
+/** registry.components: the defaults, with each known slot wrapped around its `Default`. Unknown keys are ignored. */
+export declare const compatComponents: (slots?: ViewSlots) => Record<string, any>;

package/dist/types/v3/react/view/fields.d.ts

@@ -0,0 +1,4 @@
+import type { ViewField } from "./registry";
+/** 2.x SchemaField: resolve refs, pick the field (ui:field, registry, type), render it. */
+export declare const SchemaField: ViewField;
+export declare const FormViewFields: Record<string, ViewField>;

package/dist/types/v3/react/view/host.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+import type { VChild } from "../../raw/model/vnode";
+import type { FormViewRegistryContext } from "./registry";
+export declare const viewHost: (registry: FormViewRegistryContext, hole?: ReactNode, holes?: Record<string, ReactNode>) => import("../toReact").ToReactEnv["host"];
+/** toReact with the current registry; `hole` is where a template's React children go. */
+export declare const useViewRender: () => (node: VChild, hole?: ReactNode) => ReactNode;

package/dist/types/v3/react/view/registry.d.ts

@@ -0,0 +1,34 @@
+import type { ComponentType } from "react";
+import type { Definitions } from "../../raw/core/json";
+import type { IssueSink } from "../../raw/core/issues";
+import type { FileUploadView } from "../../raw/core/policies/fileUploadView";
+export type ViewFieldProps = {
+    name: string;
+    schema: any;
+    uiSchema?: any;
+    [key: string]: any;
+};
+export type ViewField = ComponentType<ViewFieldProps>;
+export type FormViewRegistryContext = {
+    fields: Record<string, ViewField>;
+    templates: Record<string, ComponentType<any>>;
+    /** The deprecated compat map (CM-a): 2.x keys, React primitives, slots applied. */
+    components: Record<string, any>;
+    definitions: Definitions | undefined;
+    uiSchemaDefinitions: Record<string, any> | undefined;
+    formContext: Record<string, any>;
+    formLocalization?: Record<string, any>;
+    formOptions?: Record<string, any>;
+    useItemsAsAdditionalItems: boolean;
+    hideUnmarkedAdditionalProperties: boolean;
+};
+export declare const FormViewRegistry: import("react").Context<FormViewRegistryContext>;
+/** What the root knows that the 2.x registry has no key for (kept out of the C6 key set). */
+export type ViewRoot = {
+    defs?: Definitions;
+    fileUploadView?: FileUploadView;
+    sink?: IssueSink;
+};
+export declare const ViewRootContext: import("react").Context<ViewRoot>;
+/** The $refs being expanded above a React boundary (shared with Form, ../chain.ts). */
+export { ChainContext as ViewChainContext } from "../chain";

package/dist/types/v3/react/view/root.d.ts

@@ -0,0 +1,32 @@
+import type { IssueSink } from "../../raw/core/issues";
+import type { FileUploadView } from "../../raw/core/policies/fileUploadView";
+import type { ViewSlots } from "./components";
+import type { ComponentType } from "react";
+import { SchemaField } from "./fields";
+export type FormViewProps = {
+    schema: any;
+    uiSchema?: any;
+    className?: string;
+    /** Field components by name: 2.x `Field` components work unchanged (C6); `undefined` entries are ignored. */
+    fields?: Partial<Record<string, ComponentType<any>>>;
+    templates?: Record<string, any>;
+    /** Replaces `components` (D3): each slot gets the library's `Default` for its key. */
+    slots?: ViewSlots;
+    formContext?: Record<string, any>;
+    formOptions?: Record<string, any>;
+    formLocalization?: Record<string, any>;
+    useItemsAsAdditionalItems?: boolean;
+    hideUnmarkedAdditionalProperties?: boolean;
+    /** Q-FV-2: file upload fields; defaults to FILE_UPLOAD_VIEW. */
+    fileUploadView?: FileUploadView;
+    /** Receives issue codes (REF_CYCLE, KEY_REJECTED, ...). */
+    sink?: IssueSink;
+    /**
+     * @deprecated Removed in v3 (D3): use `slots`; each slot gets the library's component as `Default`.
+     * Typed `never` so a call that still passes it fails to compile; at runtime it is ignored with a warning.
+     */
+    components?: never;
+    [key: string]: unknown;
+};
+export declare const FormView: (props: FormViewProps) => import("react/jsx-runtime").JSX.Element;
+export { SchemaField };

package/dist/types/v3/react/view/templates.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from "react";
+export type ViewTemplateProps = {
+    name?: string;
+    schema?: any;
+    uiSchema?: any;
+    title?: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+    [key: string]: any;
+};
+export type ViewArrayTemplateProps = ViewTemplateProps & {
+    items?: unknown[];
+    renderItem: (item: any, index: number) => ReactNode;
+};
+export declare const FormViewTemplates: Record<"FieldTemplate" | "ObjectFieldTemplate" | "ArrayFieldTemplate", any> & Record<string, any>;