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

package/dist/types/v3/raw/dom/controller.d.ts

@@ -0,0 +1,37 @@
+import type { FormUiState } from "../model/form";
+import type { VNode } from "../model/vnode";
+import type { FormState, Store } from "../store/createStore";
+import type { ControllerInit, ControllerOptions, FormEventType, Handler } from "./types";
+export type ControllerUpdate = {
+    schema?: any;
+    uiSchema?: any;
+    values?: unknown;
+    options?: Partial<ControllerOptions>;
+};
+export declare class FormController {
+    private core;
+    private unbind?;
+    private unsubscribe;
+    private destroyed;
+    constructor(init: ControllerInit);
+    /** The RAW store (the state adapter): values, errors, touched, isSubmitting, submitCount. */
+    get store(): Store;
+    /** Draws the form into `target` and binds its events; idempotent per target. */
+    mount(target: HTMLElement): void;
+    /** New schema / uiSchema / values / options; the form is redrawn (in place). */
+    update(partial: ControllerUpdate): void;
+    /** Removes every listener (the document one too) and stops the uploads' timers; idempotent. */
+    destroy(): void;
+    getState(): FormState & {
+        ui: FormUiState;
+    };
+    /** The VNode tree of the last render: what every serialiser draws (toString / toDOM / toReact). */
+    getViewModel(): VNode | undefined;
+    /** The 2.x error map of `values`; without values, of the current ones, which then become the errors. */
+    validate(values?: unknown): Promise<unknown>;
+    /** What the submit button does: touch all, validate, then `submit` and `options.onSubmit` when valid. */
+    submit(): Promise<void>;
+    on<T extends FormEventType>(type: T, handler: Handler<T>): () => void;
+    off<T extends FormEventType>(type: T, handler: Handler<T>): void;
+    once<T extends FormEventType>(type: T, handler: Handler<T>): () => void;
+}

package/dist/types/v3/raw/dom/core.d.ts

@@ -0,0 +1,43 @@
+import type { FormAction, FormUiState } from "../model/form";
+import type { VNode } from "../model/vnode";
+import type { Store } from "../store/createStore";
+import type { UploadHost } from "./upload";
+import type { ControllerInit, ControllerOptions, FormEvent } from "./types";
+import { createEmitter } from "./emitter";
+export type Core = {
+    schema: any;
+    uiSchema: any;
+    options: ControllerOptions;
+    ui: FormUiState;
+    store: Store;
+    emitter: ReturnType<typeof createEmitter>;
+    uploads: UploadHost;
+    target?: HTMLElement;
+    /** The `on` descriptors of every element drawn (event delegation). */
+    records: WeakMap<Element, Record<string, unknown>>;
+    /** Searchable selects open in the last render: their document keydown actions (instance-scoped, Q-SEL-1). */
+    keyActions: Map<string, {
+        action: FormAction;
+        el: Element;
+    }>;
+    /** A text control's value as last drawn or reported (React's value tracker: a change fires once per new value). */
+    tracked: WeakMap<Element, string>;
+    /** The node paths of the last render (§2.7a appearances). */
+    seen: Set<string>;
+    /** Issues already emitted (a code is reported once per schema, not once per render). */
+    reported: Set<string>;
+    /** The active option scrolled into view per searchable path. */
+    scrolled: Map<string, number>;
+    /** The 2.x SchemaField props of the custom fields drawn (slot renderers get them). */
+    slotProps: Map<string, Record<string, unknown>>;
+    tree?: VNode;
+    scheduled: boolean;
+    render: () => void;
+    schedule: () => void;
+    emit: (event: FormEvent) => void;
+    dispatch: (action: FormAction, event?: object) => void;
+    element: (id: string) => HTMLElement | undefined;
+    /** Runs a store update; a failure is reported, never thrown. */
+    act: (update: () => Promise<unknown>) => void;
+};
+export declare const createCore: (init: ControllerInit, render: (core: Core) => void) => Core;

package/dist/types/v3/raw/dom/delegate.d.ts

@@ -0,0 +1,18 @@
+export type DomHandler = (on: Record<string, any>, event: Event, el: Element) => void;
+export declare const delegate: (root: Element, records: WeakMap<Element, Record<string, unknown>>, handle: DomHandler) => () => void;
+/** Controls whose value is typed: React's onChange fires on `input` for them, on `change` for the rest. */
+export declare const isTextControl: (el: Element) => boolean;
+/** What a control's change carried (the ControlEvent of applyAction). */
+export declare const controlEvent: (el: any) => {
+    checked: boolean;
+    value: any;
+    selected?: undefined;
+} | {
+    selected: any[];
+    checked?: undefined;
+    value?: undefined;
+} | {
+    value: any;
+    checked?: undefined;
+    selected?: undefined;
+};

package/dist/types/v3/raw/dom/effects.d.ts

@@ -0,0 +1,18 @@
+import type { ControlEvent, FormAction, FormUiState } from "../model/form";
+import type { Store } from "../store/createStore";
+import type { FormEvent } from "./types";
+export type EffectHost = {
+    store: Store;
+    ui: () => FormUiState;
+    setUi: (ui: FormUiState) => void;
+    emit: (event: FormEvent) => void;
+    askKey: () => string | null | undefined;
+    picker: (id: string) => void;
+    /** A store promise that failed (formik logged these from submitForm): reported, never thrown. */
+    failed: (error: unknown) => void;
+};
+export declare const runAction: (host: EffectHost, action: FormAction, event?: ControlEvent) => void;
+/** 2.x DateInput openPicker on an element of this form: the native picker, or focus + click. */
+export declare const openPicker: (el: (HTMLElement & {
+    showPicker?: () => void;
+}) | undefined) => void;

package/dist/types/v3/raw/dom/elements.d.ts

@@ -0,0 +1,17 @@
+import type { ControllerOptions } from "./types";
+import { FormController } from "./controller";
+export type FjsfFormElement = HTMLElement & {
+    schema: any;
+    uiSchema: any;
+    values: unknown;
+    options: ControllerOptions;
+    readonly controller: FormController | undefined;
+};
+/** Registers <fjsf-form> and <fjsf-form-view> (each once) in `registry`; without one (server-side) it does nothing. */
+export declare const defineFjsfElements: (registry?: CustomElementRegistry | undefined) => void;
+declare global {
+    interface HTMLElementTagNameMap {
+        "fjsf-form": FjsfFormElement;
+        "fjsf-form-view": FjsfFormElement;
+    }
+}

package/dist/types/v3/raw/dom/emitter.d.ts

@@ -0,0 +1,8 @@
+import type { FormEvent, FormEventType, Handler } from "./types";
+export declare const createEmitter: () => {
+    on: <T extends FormEventType>(type: T, handler: Handler<T>) => () => void;
+    off: <T extends FormEventType>(type: T, handler: Handler<T>) => void;
+    once: <T extends FormEventType>(type: T, handler: Handler<T>) => () => void;
+    emit: (event: FormEvent) => void;
+    clear: () => void;
+};

package/dist/types/v3/raw/dom/nodes.d.ts

@@ -0,0 +1,3 @@
+import type { VChild } from "../model/vnode";
+export declare const isDomNode: (value: any) => value is Node;
+export declare const vnodeOf: (node: Node, depth?: number) => VChild;

package/dist/types/v3/raw/dom/render.d.ts

@@ -0,0 +1,2 @@
+import type { Core } from "./core";
+export declare const renderCore: (core: Core, controller: unknown) => void;

package/dist/types/v3/raw/dom/types.d.ts

@@ -0,0 +1,112 @@
+import type { Issue } from "../core/issues";
+import type { FormUiState } from "../model/form";
+import type { FileUploadView } from "../core/policies/fileUploadView";
+import type { FormState, ValidationSchemaLike } from "../store/createStore";
+export type ChangeCause = "input" | "add" | "remove" | "move" | "default" | "prune" | "additional-key";
+/** §2.2: a discriminated union on `type`; every event fires after its state change is applied. */
+export type FormEvent = {
+    type: "change";
+    path: string;
+    value: unknown;
+    values: unknown;
+    cause: ChangeCause;
+} | {
+    type: "blur";
+    path: string;
+} | {
+    type: "submit";
+    values: unknown;
+} | {
+    type: "structure";
+    added: string[];
+    removed: string[];
+    prunedValues: string[];
+} | {
+    type: "order";
+    path: string;
+    oldOrder: string[];
+    newOrder: string[];
+} | {
+    type: "validate";
+    errors: unknown;
+} | ({
+    type: "error";
+} & Issue);
+export type FormEventType = FormEvent["type"];
+export type EventOf<T extends FormEventType> = Extract<FormEvent, {
+    type: T;
+}>;
+export type Handler<T extends FormEventType> = (event: EventOf<T>) => void;
+/** The props a RAW field renderer gets for its slot (2.x SchemaField props, plus the value). */
+export type SlotField = {
+    name: string;
+    schema: unknown;
+    uiSchema: unknown;
+    required?: boolean;
+    value: unknown;
+};
+/**
+ * §2.6 RAW slot: fills the `<div data-fjsf-slot>` of a field the host provides. Called after every render
+ * with the same element while the field stays in place (it owns the element's content).
+ */
+export type SlotRenderer = (slot: HTMLElement, field: SlotField, controller: unknown) => void;
+/** The host's upload functions (the shape of the React FileUploadContext / FilesUploadContext). */
+export type UploadProgress = {
+    loaded: number;
+    total?: number | null;
+};
+export type Uploads = {
+    file?: {
+        uploadFile: (x: {
+            data: FormData;
+            onUploadProgress?: (e: UploadProgress) => void;
+        }) => Promise<unknown>;
+        fetchFile: (value: any) => Promise<{
+            name: string;
+        } | null | undefined>;
+        removeFile: (fileName: string) => Promise<unknown>;
+    };
+    files?: {
+        uploadFiles: (x: {
+            files: {
+                data: File;
+                progressId: string;
+            }[];
+            onUploadProgress?: (e: UploadProgress, progressId: string) => void;
+        }) => Promise<any[]>;
+        removeFile: (file: any) => Promise<unknown>;
+    };
+};
+export type ControllerOptions = {
+    /** "form" (default): the editable Form; "view": the read-only FormView. */
+    mode?: "form" | "view";
+    validationSchema?: ValidationSchemaLike;
+    validateOnChange?: boolean;
+    validateOnBlur?: boolean;
+    onSubmit?: (values: any) => unknown;
+    className?: string;
+    hideSubmit?: boolean;
+    formLocalization?: any;
+    formOptions?: any;
+    hideUnmarkedAdditionalProperties?: boolean;
+    /** Additional properties get up/down buttons and `order` events (2.x: an onAdditionalPropertyOrderChange prop). */
+    orderable?: boolean;
+    /** RAW custom fields by name (`ui:field` strings and replaced built-ins). */
+    fields?: Record<string, SlotRenderer>;
+    uploads?: Uploads;
+    /** DateField's default locale (2.x read navigator.language; RAW reads no globals). */
+    locale?: string;
+    /** Q-FV-2, view mode. */
+    fileUploadView?: FileUploadView;
+    /** propertyAdd asks for the new key (2.x `prompt("Give key")`); default: globalThis.prompt when there is one. */
+    askKey?: () => string | null | undefined;
+};
+export type ControllerInit = {
+    schema: any;
+    uiSchema?: any;
+    values?: unknown;
+    state?: Partial<FormState> & {
+        ui?: FormUiState;
+    };
+    options?: ControllerOptions;
+};

package/dist/types/v3/raw/dom/upload.d.ts

@@ -0,0 +1,16 @@
+import type { FieldProps } from "../model/form/chrome";
+import type { FormBuildContext } from "../model/form";
+import type { VChild } from "../model/vnode";
+import type { Uploads } from "./types";
+export type UploadHost = ReturnType<typeof createUploads>;
+export declare const createUploads: (host: {
+    uploads: () => Uploads | undefined;
+    values: () => unknown;
+    setValue: (path: string, value: unknown) => void;
+    rerender: () => void;
+    pick: (id: string) => void;
+}) => {
+    markup: (ctx: FormBuildContext, field: string, p: FieldProps) => VChild;
+    handle: (action: any, event: Event, el: Element) => boolean;
+    destroy: () => void;
+};

package/dist/types/v3/raw/i18n/en.d.ts

@@ -0,0 +1,42 @@
+export declare const en: {
+    readonly "validation.error.required": "Required";
+    readonly "validation.error.minLength": "Must be at least {limit} characters";
+    readonly "validation.error.maxLength": "Must be at most {limit} characters";
+    readonly "validation.error.pattern": "Invalid format";
+    readonly "validation.error.minimum": "Must be at least {min}";
+    readonly "validation.error.maximum": "Must be at most {max}";
+    readonly "validation.error.exclusiveMinimum": "Must be more than {min}";
+    readonly "validation.error.exclusiveMaximum": "Must be less than {max}";
+    readonly "validation.error.multipleOf": "Must be a multiple of {multipleOf}";
+    readonly "validation.error.minItems": "Must have at least {min} items";
+    readonly "validation.error.maxItems": "Must have at most {max} items";
+    readonly "validation.error.uniqueItems": "Items must be unique";
+    readonly "validation.error.enum": "Invalid value";
+    readonly "validation.error.const": "Invalid value";
+    readonly "validation.error.notConst": "Invalid value";
+    readonly "form.submit": "Send";
+    readonly "form.additionalProperty.prompt": "Give key";
+    readonly "view.boolean.selected": "Selected";
+    readonly "view.boolean.notSelected": "Not selected";
+    readonly "field.date.picker": "Date picker";
+    readonly "field.unsupported": "!!! Unsupported field \"{name}\" !!!";
+    readonly "code.SCHEMA_UNSUPPORTED_TYPE": "Unsupported field type";
+    readonly "code.SCHEMA_MISSING_TYPE": "Field has no type";
+    readonly "code.SCHEMA_ARRAY_AMBIGUOUS": "Array item schema is ambiguous";
+    readonly "code.SCHEMA_ENUM_CONFLICT": "More than one of enum, oneOf and anyOf; enum wins, then oneOf";
+    readonly "code.REF_UNSUPPORTED": "Unsupported reference";
+    readonly "code.REF_NOT_FOUND": "Reference not found";
+    readonly "code.REF_CYCLE": "Circular reference";
+    readonly "code.REF_DEPTH_EXCEEDED": "Reference nesting is too deep";
+    readonly "code.PATTERN_INVALID": "Invalid pattern";
+    readonly "code.PATTERN_REJECTED": "Unsafe pattern was ignored";
+    readonly "code.PROP_REJECTED": "Property is not allowed";
+    readonly "code.KEY_REJECTED": "Key is not allowed";
+    readonly "code.KEY_AMBIGUOUS": "Key contains path characters";
+    readonly "code.FIELD_UNKNOWN": "Unknown field";
+    readonly "code.TEMPLATE_UNKNOWN": "Unknown template";
+    readonly "code.TEMPLATE_DISABLED": "Template is disabled here";
+    readonly "code.DOCUMENT_INVALID": "Document is not valid: the schema or a part of it was replaced";
+    readonly "code.SANITIZER_UNAVAILABLE": "HTML sanitiser is unavailable";
+};
+export type MessageKey = keyof typeof en;

package/dist/types/v3/raw/i18n/fi.d.ts

@@ -0,0 +1,2 @@
+import type { MessageKey } from "./en";
+export declare const fi: Record<MessageKey, string>;

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

@@ -0,0 +1,9 @@
+import type { MessageKey } from "./en";
+import { en } from "./en";
+import { fi } from "./fi";
+export type Locale = "en" | "fi";
+export type Translate = (key: MessageKey | string, params?: Record<string, unknown>) => string;
+export declare const catalogs: Record<Locale, Record<MessageKey, string>>;
+export declare const createTranslator: (locale?: Locale, overrides?: Partial<Record<string, string>>) => Translate;
+export type { MessageKey };
+export { en, fi };

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

@@ -0,0 +1,43 @@
+export * from "./core/json";
+export * from "./core/issues";
+export * from "./core/paths";
+export { getSchemaType, guessType, normaliseType, defaultValueForType } from "./core/schemaType";
+export type { NormalisedType } from "./core/schemaType";
+export { mergeSchemas } from "./core/merge";
+export { MAX_REF_DEPTH, hasReferences, parseRef, resolveRefs, solveReferences } from "./core/refs";
+export type { RefContext, Resolved } from "./core/refs";
+export { itemSchema, normalizeArraySchema, valueTypeMismatch } from "./core/arrays";
+export type { ItemSchema, NormalisedArray } from "./core/arrays";
+export { deepOverlap, resolveOneOfValue, resolveSchema } from "./core/conditionals";
+export { defaultFor, isUnset, localIsoDate } from "./core/defaults";
+export type { DefaultOptions } from "./core/defaults";
+export { createInitialValues } from "./core/initialValues";
+export type { InitialValuesOptions, InitialValuesType } from "./core/initialValues";
+export { OPTIONAL_NUMBER_INITIAL, optionalNumberInitialValue } from "./core/policies/optionalNumberInitial";
+export type { OptionalNumberInitial } from "./core/policies/optionalNumberInitial";
+export { FILE_UPLOAD_VIEW } from "./core/policies/fileUploadView";
+export type { FileUploadView } from "./core/policies/fileUploadView";
+export * from "./core/uiSchema";
+export * from "./core/enums";
+export { immutablySwapItems, setTitleValues } from "./core/titles";
+export { createValidationSchema } from "./validation";
+export type { LocalizeType, ValidationOptions } from "./validation";
+export { DEFAULT_PATTERN_INPUT_CAP, isUnsafePattern } from "./validation/patterns";
+export { catalogs, createTranslator, en, fi } from "./i18n";
+export type { Locale, MessageKey, Translate } from "./i18n";
+export * from "./sanitize";
+export { cx, h } from "./model/vnode";
+export type { AttrValue, Attrs, VChild, VNode } from "./model/vnode";
+export { escapeAttr, escapeText, toString as vnodeToString } from "./serialize/toString";
+export { buildViewNode, renderViewToString } from "./model/view";
+export type { ArrayItem, FieldKind, SectionNode, ViewChild, ViewNode, ViewOptions } from "./model/view/types";
+export { toDOM } from "./serialize/toDOM";
+export type { DomEnv } from "./serialize/toDOM";
+export { createStore } from "./store/createStore";
+export type { FormState, Store, StoreOptions, ValidationSchemaLike } from "./store/createStore";
+export { FormController } from "./dom/controller";
+export type { ControllerUpdate } from "./dom/controller";
+export { defineFjsfElements } from "./dom/elements";
+export type { FjsfFormElement } from "./dom/elements";
+export type * from "./dom/types";
+export { cssVarsToString, fjsfClassNames, fjsfSelectors, getDefaultStyles, themeToCssVars } from "./styles";

package/dist/types/v3/raw/model/classes.d.ts

@@ -0,0 +1,2 @@
+/** The classes with every extended component's bases, each once, bases first. */
+export declare const expandClasses: (classes: readonly string[]) => string[];

package/dist/types/v3/raw/model/form/actions.d.ts

@@ -0,0 +1,41 @@
+import type { FormAction, FormUiState } from "./types";
+/** What the DOM event carried. */
+export type ControlEvent = {
+    value?: string;
+    checked?: boolean;
+    selected?: string[];
+    /** propertyAdd: the key the host asked for (prompt). */
+    key?: string | null;
+    /** Keyboard key (searchKey). */
+    keyName?: string;
+    /** Focus moved outside the field's container (searchLeave). */
+    leftContainer?: boolean;
+};
+export type ActionEffect = {
+    /** Set the value at a path (`""`: the root values). */
+    set?: {
+        path: string;
+        value: unknown;
+    };
+    touch?: string;
+    ui?: FormUiState;
+    /** 2.x onAdditionalPropertyOrderChange(path, previous, next). */
+    order?: {
+        path: string;
+        previous: string[];
+        next: string[];
+    };
+    submit?: true;
+    /** propertyAdd asks the host for a key (2.x `prompt("Give key")`). */
+    askKey?: true;
+    /** Mark touched without validating (2.x setFieldTouched(name, true, false)). */
+    touchQuietly?: string;
+    /** Set (or clear, `message: undefined`) a field error (2.x helpers.setError). */
+    error?: {
+        path: string;
+        message?: string;
+    };
+    /** Open the native date picker of this element (host-side, imperative). */
+    picker?: string;
+};
+export declare const applyAction: (action: FormAction, values: unknown, e?: ControlEvent, ui?: FormUiState) => ActionEffect;

package/dist/types/v3/raw/model/form/any.d.ts

@@ -0,0 +1,5 @@
+import type { VChild } from "../vnode";
+import type { ChildProps } from "./dispatch";
+import type { Trail } from "../../core/trail";
+import type { FormBuildContext } from "./types";
+export declare const anyField: (ctx: FormBuildContext, p: ChildProps, chain: string[], trail?: Trail) => VChild;

package/dist/types/v3/raw/model/form/appearance.d.ts

@@ -0,0 +1,9 @@
+import type { Appearance } from "./types";
+/** The nodes that appeared in this render and not in the previous one; `seen` becomes this render's set. */
+export declare const newAppearances: (appeared: Appearance[], seen: Set<string>) => Appearance[];
+export type Prune = {
+    path: string;
+    keys: string[];
+};
+/** The values with the defaults of the fresh nodes and the prunes applied (the same object when nothing changes). */
+export declare const settle: (values: unknown, fresh: Appearance[], prune: Prune[], now?: Date) => unknown;

package/dist/types/v3/raw/model/form/array.d.ts

@@ -0,0 +1,4 @@
+import type { VChild } from "../vnode";
+import type { ChildProps } from "./dispatch";
+import type { FormBuildContext } from "./types";
+export declare const arrayField: (ctx: FormBuildContext, p: ChildProps, _chain: string[]) => VChild;

package/dist/types/v3/raw/model/form/choice.d.ts

@@ -0,0 +1,16 @@
+import type { VChild } from "../vnode";
+import type { FieldProps } from "./chrome";
+import type { FormBuildContext } from "./types";
+import { getEnums } from "../../core/enums";
+/** RadioField: true/false radios. formik checked them by strict equality with the string value (kept). */
+export declare const radioField: (ctx: FormBuildContext, p: FieldProps) => VChild;
+/** The RadioFieldInput markup (also the default of FormComponents.RadioFieldInput). */
+export declare const radioInputsMarkup: (ctx: FormBuildContext, props: FieldProps, label: unknown) => VChild;
+/** ToggleField: a checkbox (stores a boolean, Q-R19-1) and the toggle. */
+export declare const toggleField: (ctx: FormBuildContext, p: FieldProps) => VChild;
+/** The ToggleFieldInput markup (also the default of FormComponents.ToggleFieldInput). */
+export declare const toggleInputMarkup: (ctx: FormBuildContext, props: FieldProps) => VChild;
+/** MultipleChoiceField: one radio (single) or checkbox (multi) per option; stores the consts. */
+export declare const multipleChoiceField: (ctx: FormBuildContext, p: FieldProps) => VChild;
+/** The MultipleChoiceFieldInput markup (also the default of FormComponents.MultipleChoiceFieldInput). */
+export declare const choicesInputMarkup: (ctx: FormBuildContext, props: FieldProps, enums: ReturnType<typeof getEnums>, style: unknown) => VChild;

package/dist/types/v3/raw/model/form/chrome.d.ts

@@ -0,0 +1,20 @@
+import type { Attrs, VChild } from "../vnode";
+import type { FormChrome } from "./markup";
+import type { FormBuildContext } from "./types";
+export type FieldProps = {
+    name: string;
+    schema: any;
+    ui: any;
+    required?: boolean;
+    kind?: string;
+    hidden?: boolean;
+    /** The data-* props a 2.x field passed to its template (data-fjsf-string, data-fjsf-object, ...). */
+    data?: Attrs;
+};
+/** 2.x getInstrumentationAttributes. */
+export declare const instrumentation: (p: FieldProps) => Attrs;
+/** ErrorMessage (2.x: useField meta, shown when touched): a composite so pro3's HiddenErrorMessage can replace it. */
+export declare const errorMarkup: (ctx: FormBuildContext, name: string, errorProps?: unknown) => VChild;
+/** FieldInfo (ui:info): tooltip, or an inline box toggled by the info link (formOptions.components.FieldInfo.display). */
+export declare const infoMarkup: (ctx: FormBuildContext, path: string, info: any) => VChild;
+export declare const formChrome: (ctx: FormBuildContext, p: FieldProps, withError?: boolean) => FormChrome;

package/dist/types/v3/raw/model/form/componentTable.d.ts

@@ -0,0 +1,2 @@
+export type FormComponentEntry = readonly [tag: string, ...chain: string[]] | null | "fn";
+export declare const FORM_COMPONENTS: Readonly<Record<string, FormComponentEntry>>;

package/dist/types/v3/raw/model/form/date.d.ts

@@ -0,0 +1,13 @@
+import type { VChild } from "../vnode";
+import type { FieldProps } from "./chrome";
+import type { FormBuildContext } from "./types";
+/** What a date commit needs to know (2.x DateInput props). */
+export type DateRules = {
+    locale: string;
+    min?: string;
+    max?: string;
+    invalid: string;
+    outOfRange: string;
+};
+export declare const dateRules: (ctx: FormBuildContext, ui: any) => DateRules;
+export declare const dateField: (ctx: FormBuildContext, p: FieldProps) => VChild;

package/dist/types/v3/raw/model/form/dispatch.d.ts

@@ -0,0 +1,13 @@
+import type { VChild } from "../vnode";
+import type { FieldProps } from "./chrome";
+import type { FormBuildContext } from "./types";
+import type { Trail } from "../../core/trail";
+export declare const COMPONENT_TYPES: Record<string, string>;
+/** Built-in field names of slice S5. */
+export declare const S5_FIELDS: Set<string>;
+export type ChildProps = FieldProps & {
+    forceDefaultValue?: boolean;
+};
+export declare const formField: (ctx: FormBuildContext, p: ChildProps, chain?: string[], trail?: Trail) => VChild;
+/** One built-in field by name (2.x `FormFields.X`). */
+export declare const builtIn: (ctx: FormBuildContext, component: string, p: ChildProps, chain?: string[], trail?: Trail) => VChild;

package/dist/types/v3/raw/model/form/iconData.d.ts

@@ -0,0 +1,4 @@
+export declare const ICONS: Readonly<Record<string, {
+    viewBox: string;
+    paths: readonly string[];
+}>>;

package/dist/types/v3/raw/model/form/icons.d.ts

@@ -0,0 +1,2 @@
+import type { VNode } from "../vnode";
+export declare const iconMarkup: (name: string, className?: string) => VNode;

package/dist/types/v3/raw/model/form/index.d.ts

@@ -0,0 +1,38 @@
+import type { Definitions } from "../../core/json";
+import type { IssueSink } from "../../core/issues";
+import type { VChild, VNode } from "../vnode";
+import type { FormBuildContext, FormUiState } from "./types";
+export type FormState = {
+    values: unknown;
+    errors?: unknown;
+    touched?: unknown;
+    submitting?: boolean;
+};
+export type FormOptions = {
+    customFields?: string[];
+    formLocalization?: any;
+    formOptions?: any;
+    locale?: string;
+    ui?: FormUiState;
+    hideUnmarkedAdditionalProperties?: boolean;
+    orderable?: boolean;
+    sink?: IssueSink;
+    definitions?: Definitions;
+    defs?: Definitions;
+    uiDefinitions?: any;
+};
+export declare const createFormContext: (schema: any, uiSchema: any, state: FormState, o?: FormOptions) => FormBuildContext;
+/** 2.x <Form>: formik's <form action="#"> (registry Form), the fields, then the caller's children or the submit button. */
+export declare const formShell: (content: VChild, o: {
+    className?: string;
+    hideSubmit?: boolean;
+    submitting?: boolean;
+    children?: VChild;
+}) => VNode;
+export { applyAction } from "./actions";
+export type { ActionEffect, ControlEvent } from "./actions";
+export { newAppearances, settle } from "./appearance";
+export type { Prune } from "./appearance";
+export { builtIn, formField, S5_FIELDS } from "./dispatch";
+export type { ChildProps } from "./dispatch";
+export type * from "./types";

package/dist/types/v3/raw/model/form/leaf.d.ts

@@ -0,0 +1,29 @@
+import type { Attrs, VChild } from "../vnode";
+import type { FieldProps } from "./chrome";
+import type { FormBuildContext } from "./types";
+/** `ui:props` for the control (2.x spread them verbatim), through the D5 allowlist. */
+export declare const inputAttrs: (ctx: FormBuildContext, p: FieldProps) => Attrs;
+/** The control's actions. Q-RO-1: a readOnly control never changes the value (browsers ignore readonly on select/checkbox). */
+export declare const on: (p: FieldProps, parse: "text" | "number" | "checkbox" | "enum" | "multi" | "radio", consts?: unknown[]) => {
+    blur: {
+        type: string;
+        path: string;
+    };
+    click?: {
+        type: string;
+    } | undefined;
+    change?: {
+        consts?: unknown[] | undefined;
+        type: string;
+        path: string;
+        parse: "number" | "enum" | "radio" | "text" | "checkbox" | "multi";
+    } | undefined;
+};
+/** StringField / NumberField: an input, or a select for `oneOf`/`enum` consts. */
+export declare const stringField: (ctx: FormBuildContext, p: FieldProps, numberField?: boolean) => VChild;
+/** What an input shows for a stored value (React renders primitives; objects and arrays are not shown). */
+export declare const textValue: (value: unknown) => string;
+export declare const textAreaField: (ctx: FormBuildContext, p: FieldProps) => VChild;
+/** BooleanField: a checkbox (stores true/false, Q-R19-1) and its ui:label, which toggles on click (BUG-FMK-1: nested path). */
+export declare const booleanField: (ctx: FormBuildContext, p: FieldProps) => VChild;
+export declare const nullField: (ctx: FormBuildContext, p: FieldProps) => VChild;