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

package/dist/esm/v3/raw/core/paths.js

@@ -0,0 +1,79 @@
+// Path handling for the RAW core (§2.4). Internal paths are segment arrays; the
+// Formik string form (`a[0].b`) is derived. No formik import: its getIn would pull
+// React into RAW. Prototype keys are never traversed (SEC-8 / SEC-FMK-5).
+import { hasOwn, PROTOTYPE_KEYS } from "./json";
+/** Splits a Formik/lodash path string: `a.b[0].c` -> ["a", "b", 0, "c"]. */
+export const toPath = (path) => {
+    if (Array.isArray(path))
+        return path;
+    if (path === "")
+        return [];
+    const segments = [];
+    path.replace(/\[(\d+)\]|\[["']([^"']*)["']\]|([^.[\]]+)/g, (_m, index, quoted, plain) => {
+        if (index !== undefined)
+            segments.push(Number(index));
+        else
+            segments.push(quoted !== undefined ? quoted : plain);
+        return "";
+    });
+    return segments;
+};
+/** Formik string form of a path: ["a", 0, "b"] -> "a[0].b"; root is "". */
+export const toFormikPath = (path) => path.reduce((acc, segment) => {
+    if (typeof segment === "number")
+        return `${acc}[${segment}]`;
+    return acc === "" ? segment : `${acc}.${segment}`;
+}, "");
+export const isPrototypeKey = (key) => PROTOTYPE_KEYS.has(key);
+/** A key the Formik string form cannot address without changing its meaning (Q-FMK-4). */
+export const isAmbiguousKey = (key) => /[.[\]]/.test(key);
+/** Reads a value; undefined when any step is missing, wrong-typed or a prototype key. */
+export const getIn = (value, path) => {
+    let current = value;
+    for (const segment of toPath(path)) {
+        if (current === null || typeof current !== "object")
+            return undefined;
+        const key = String(segment);
+        if (isPrototypeKey(key) || !hasOwn(current, key))
+            return undefined;
+        current = current[key];
+    }
+    return current;
+};
+/** Formik/lodash: a missing container becomes an array when the next key is a non-negative integer. */
+const isIndex = (segment) => typeof segment === "number" || /^(0|[1-9]\d*)$/.test(segment);
+const cloneContainer = (value, nextSegment) => {
+    if (Array.isArray(value))
+        return value.slice();
+    if (value !== null && typeof value === "object")
+        return { ...value };
+    return isIndex(nextSegment) ? [] : {};
+};
+/**
+ * Immutable write. Returns the original value unchanged when the path contains a
+ * prototype key (the caller reports KEY_REJECTED). Wrong-typed intermediate values
+ * are replaced by a fresh container, like Formik's setIn.
+ */
+export const setIn = (value, path, next) => {
+    const segments = toPath(path);
+    if (segments.length === 0)
+        return next;
+    if (segments.some((s) => typeof s === "string" && isPrototypeKey(s)))
+        return value;
+    const write = (current, index) => {
+        const segment = segments[index];
+        const container = cloneContainer(current, segment);
+        const key = String(segment);
+        if (index === segments.length - 1) {
+            if (next === undefined && !Array.isArray(container))
+                delete container[key];
+            else
+                container[key] = next;
+            return container;
+        }
+        const child = hasOwn(current, key) ? current[key] : undefined;
+        container[key] = write(child, index + 1);
+        return container;
+    };
+    return write(value, 0);
+};

package/dist/esm/v3/raw/core/policies/fileUploadView.js

@@ -0,0 +1 @@
+export const FILE_UPLOAD_VIEW = "todo";

package/dist/esm/v3/raw/core/policies/optionalNumberInitial.js

@@ -0,0 +1,3 @@
+export const OPTIONAL_NUMBER_INITIAL = "absent";
+/** `undefined` means "leave the key out". */
+export const optionalNumberInitialValue = (policy = OPTIONAL_NUMBER_INITIAL) => policy === "zero" ? 0 : policy === "empty" ? "" : undefined;

package/dist/esm/v3/raw/core/policies/storedFormats.js

@@ -0,0 +1,2 @@
+export const MULTI_SELECT_STORAGE = "strings";
+export const BOOLEAN_RADIO_STORAGE = "strings";

package/dist/esm/v3/raw/core/refs.js

@@ -0,0 +1,97 @@
+import { hasOwn, isPlainObject, PROTOTYPE_KEYS } from "./json";
+import { ignoreIssues, issue } from "./issues";
+import { mergeSchemas } from "./merge";
+/** Maximum alias hops / nested expansions of the same chain (plan §5.2 SEC-9). */
+export const MAX_REF_DEPTH = 32;
+const decode = (segment) => {
+    let s = segment.replace(/~1/g, "/").replace(/~0/g, "~");
+    try {
+        s = decodeURIComponent(s);
+    }
+    catch {
+        // keep the raw segment when it is not valid percent-encoding
+    }
+    return s;
+};
+/** Parses `#/definitions/a~1b` style pointers; undefined for anything else. */
+export const parseRef = (ref) => {
+    const match = /^#\/(definitions|\$defs)\/(.+)$/.exec(ref);
+    if (!match)
+        return undefined;
+    return { root: match[1], segments: match[2].split("/").map(decode) };
+};
+const walk = (container, segments) => {
+    let current = container;
+    for (const segment of segments) {
+        if (PROTOTYPE_KEYS.has(segment) || !hasOwn(current, segment))
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+};
+/** uiSchema definitions are keyed without the intermediate `properties` segments (2.x mapping). */
+const uiTarget = (ui, segments) => walk(ui, segments.filter((s) => s !== "properties"));
+/**
+ * Resolves the `$ref` of one schema node. Never throws: unsupported, missing,
+ * cyclic or too deep references produce an issue and a schema without `$ref`.
+ */
+export const resolveRefs = (schema, uiSchema, ctx) => {
+    const sink = ctx.sink ?? ignoreIssues;
+    if (!isPlainObject(schema) || typeof schema.$ref !== "string")
+        return { schema, uiSchema };
+    const visited = new Set();
+    let current = schema;
+    let ui = uiSchema ?? {};
+    let depth = 0;
+    while (isPlainObject(current) && typeof current.$ref === "string") {
+        const ref = current.$ref;
+        const { $ref: _drop, ...rest } = current;
+        if (visited.has(ref)) {
+            sink(issue("REF_CYCLE", ctx.path, ref));
+            return { schema: rest, uiSchema: ui };
+        }
+        if (depth >= MAX_REF_DEPTH) {
+            sink(issue("REF_DEPTH_EXCEEDED", ctx.path, ref));
+            return { schema: rest, uiSchema: ui };
+        }
+        visited.add(ref);
+        depth += 1;
+        const pointer = parseRef(ref);
+        if (!pointer) {
+            sink(issue("REF_UNSUPPORTED", ctx.path, ref));
+            return { schema: rest, uiSchema: ui };
+        }
+        const source = pointer.root === "definitions" ? ctx.definitions : ctx.defs;
+        const target = walk(source, pointer.segments);
+        if (!isPlainObject(target)) {
+            sink(issue("REF_NOT_FOUND", ctx.path, ref));
+            return { schema: rest, uiSchema: ui };
+        }
+        const uiDefinition = pointer.root === "definitions" ? uiTarget(ctx.uiSchemaDefinitions, pointer.segments) : undefined;
+        ui = mergeSchemas(isPlainObject(uiDefinition) ? uiDefinition : {}, ui);
+        current = mergeSchemas(target, rest);
+        if (!hasOwn(target, "$ref"))
+            delete current.$ref;
+    }
+    return { schema: current, uiSchema: ui };
+};
+/**
+ * 2.x-compatible signature (src/utils/solveReferences.ts): `definitions` is the
+ * root `definitions`. `$defs` is read from the same object when given via ctx.
+ */
+export const solveReferences = (schema, definitions, uiSchema, uiSchemaDefinitions, options = {}) => resolveRefs(schema, uiSchema, { ...options, definitions, uiSchemaDefinitions });
+/** Q-REF-5 (kept, documented): only `properties` are inspected. Cycle-safe (Q-PP-3). */
+export const hasReferences = (schema, seen = new Set()) => {
+    const properties = isPlainObject(schema) ? schema.properties : undefined;
+    if (!isPlainObject(properties) || seen.has(schema))
+        return false;
+    seen.add(schema);
+    return Object.keys(properties).some((key) => {
+        const value = properties[key];
+        if (!isPlainObject(value))
+            return false;
+        if (value.properties)
+            return hasReferences(value, seen);
+        return Object.keys(value).includes("$ref");
+    });
+};

package/dist/esm/v3/raw/core/schemaType.js

@@ -0,0 +1,68 @@
+import { isSchemaObject } from "./json";
+/** Same answer as 2.x getTypes.getSchemaType for every input 2.x accepted. */
+export const getSchemaType = (schema) => {
+    if (!isSchemaObject(schema))
+        return undefined;
+    const { type } = schema;
+    if (!type && schema.const)
+        return guessType(schema.const);
+    if (!type && schema.enum)
+        return "string";
+    if (!type && (schema.properties || schema.additionalProperties))
+        return "object";
+    if (Array.isArray(type) && type.length === 2 && type.includes("null"))
+        return type.find((t) => t !== "null");
+    return type;
+};
+/** 2.x guessType (getTypes.ts), unchanged: used for `const` type guessing. */
+export const guessType = (value) => {
+    if (Array.isArray(value))
+        return "array";
+    if (typeof value === "string")
+        return "string";
+    if (value === null)
+        return "null";
+    if (typeof value === "boolean")
+        return "boolean";
+    if (!isNaN(value))
+        return "number";
+    if (typeof value === "object")
+        return "object";
+    return "string";
+};
+/**
+ * v3 normalisation used by initial values and validation: always one type plus a
+ * nullable flag; "any" when nothing can be inferred (never a throw).
+ */
+export const normaliseType = (schema) => {
+    if (!isSchemaObject(schema))
+        return { type: "any", nullable: false };
+    const raw = schema.type;
+    if (Array.isArray(raw)) {
+        const nonNull = raw.filter((t) => t !== "null");
+        return { type: nonNull[0] ?? (raw.length ? "null" : "any"), nullable: raw.includes("null") };
+    }
+    if (raw)
+        return { type: raw, nullable: false };
+    if (schema.const !== undefined)
+        return { type: guessType(schema.const), nullable: false };
+    if (schema.enum && schema.enum.length > 0) {
+        const kinds = new Set(schema.enum.map((v) => (v === null ? "null" : guessType(v))));
+        return { type: kinds.size === 1 ? [...kinds][0] : "any", nullable: kinds.has("null") };
+    }
+    if (schema.properties || schema.additionalProperties)
+        return { type: "object", nullable: false };
+    if (schema.items || schema.additionalItems)
+        return { type: "array", nullable: false };
+    return { type: "any", nullable: false };
+};
+/** Default value used when an item or property is created (2.x getDefaultValueForType). */
+export const defaultValueForType = (type) => {
+    if (type && !Array.isArray(type)) {
+        if (type === "array")
+            return [];
+        if (type === "object")
+            return {};
+    }
+    return undefined;
+};

package/dist/esm/v3/raw/core/titles.js

@@ -0,0 +1,25 @@
+// setTitleValues and immutablySwapItems ported from 2.x. setTitleValues no longer
+// throws when the stored value at `name` is not an array (2.x: `getIn(...)[index]`).
+import { getIn } from "./paths";
+// Replaces ${key} placeholders in a collapsible title with the item's values.
+export const setTitleValues = (name, title, defaultTitle, values) => {
+    const match = name.match(/^([a-zA-Z_$][\w[\].$]*)\[(\d+)\]$/);
+    const base = match ? match[1] : name;
+    const index = match ? parseInt(match[2], 10) : -1;
+    const container = getIn(values, base);
+    const itemValues = match ? (Array.isArray(container) ? container[index] : undefined) : container;
+    const fallbackName = base.split(".").slice(-1)[0];
+    return title.replace(/\$\{([\w$.:]+)\}/g, (placeholder) => {
+        const key = placeholder.slice(2, -1);
+        const value = itemValues ? getIn(itemValues, key) : undefined;
+        if (key === "index")
+            return (index + 1).toString();
+        return value ? String(value) : defaultTitle || fallbackName;
+    });
+};
+export function immutablySwapItems(items, firstIndex, secondIndex) {
+    const results = items.slice();
+    results[firstIndex] = items[secondIndex];
+    results[secondIndex] = items[firstIndex];
+    return results;
+}

package/dist/esm/v3/raw/core/trail.js

@@ -0,0 +1,14 @@
+import { issue } from "./issues";
+import { MAX_SCHEMA_DEPTH } from "./json";
+/** True when `node` may be expanded below `trail`; otherwise reports REF_CYCLE or REF_DEPTH_EXCEEDED and returns false. */
+export const mayEnter = (node, trail, sink, path) => {
+    if (trail.includes(node)) {
+        sink(issue("REF_CYCLE", path || undefined));
+        return false;
+    }
+    if (trail.length >= MAX_SCHEMA_DEPTH) {
+        sink(issue("REF_DEPTH_EXCEEDED", path || undefined));
+        return false;
+    }
+    return true;
+};

package/dist/esm/v3/raw/core/uiProps.js

@@ -0,0 +1,68 @@
+import { issue } from "./issues";
+import { isPlainObject } from "./json";
+/** Allowed keys (React names) and the HTML attribute each becomes. */
+const KEYS = {
+    placeholder: "placeholder", autoComplete: "autocomplete", inputMode: "inputmode", min: "min", max: "max", step: "step",
+    maxLength: "maxlength", className: "class", title: "title", id: "id", tabIndex: "tabindex", disabled: "disabled", readOnly: "readonly",
+};
+/**
+ * Style properties (camelCase) allowed in `style`: typography, colour, box and flex/grid layout.
+ * Not allowed: positioning (`position`, `inset`, `top`..., `zIndex`), `background(-image)`,
+ * `content`, `transform`, `filter`, anything with `url(`, `expression(` or `javascript:` (provisional).
+ */
+export const STYLE_PROPERTIES = new Set([
+    "color", "backgroundColor", "opacity", "fontFamily", "fontSize", "fontStyle", "fontWeight", "lineHeight", "letterSpacing",
+    "textAlign", "textDecoration", "textTransform", "whiteSpace", "wordBreak", "overflowWrap", "verticalAlign",
+    "display", "boxSizing", "width", "minWidth", "maxWidth", "height", "minHeight", "maxHeight", "overflow",
+    "margin", "marginTop", "marginRight", "marginBottom", "marginLeft", "padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft",
+    "border", "borderTop", "borderRight", "borderBottom", "borderLeft", "borderColor", "borderStyle", "borderWidth", "borderRadius",
+    "flex", "flexDirection", "flexWrap", "flexGrow", "flexShrink", "flexBasis", "alignItems", "alignSelf", "justifyContent", "gap",
+    "rowGap", "columnGap", "gridTemplateColumns", "gridColumn", "gridRow", "breakInside", "breakBefore", "breakAfter",
+    "pageBreakInside", "pageBreakBefore", "pageBreakAfter",
+]);
+const UNSAFE_VALUE = /url\s*\(|expression\s*\(|javascript:|@import|[<>{};\\]/i;
+const kebab = (name) => name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+const primitive = (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean";
+const styleOf = (style, rejected) => {
+    if (!isPlainObject(style)) {
+        rejected.push("style");
+        return undefined;
+    }
+    const rules = [];
+    for (const [name, value] of Object.entries(style)) {
+        if (STYLE_PROPERTIES.has(name) && (typeof value === "string" || typeof value === "number") && !UNSAFE_VALUE.test(String(value)))
+            rules.push(`${kebab(name)}:${value}`);
+        else
+            rejected.push(`style.${name}`);
+    }
+    return rules.length ? rules.join(";") : undefined;
+};
+/** `{attrs, rejected}`: HTML attributes for a library element; rejected keys are reported on `sink`. */
+export const filterUiProps = (uiProps, path = "", sink) => {
+    const attrs = {};
+    const rejected = [];
+    if (uiProps === undefined || uiProps === null)
+        return { attrs, rejected };
+    if (!isPlainObject(uiProps))
+        rejected.push("(not an object)");
+    else {
+        for (const [key, value] of Object.entries(uiProps)) {
+            const isData = /^data-[a-z0-9-]+$/i.test(key) && !/^data-(fjsf-|keyword$)/i.test(key);
+            const isAria = /^aria-[a-z]+$/i.test(key);
+            if (key === "style") {
+                const css = styleOf(value, rejected);
+                if (css)
+                    attrs.style = css;
+            }
+            else if ((isData || isAria || Object.prototype.hasOwnProperty.call(KEYS, key)) && primitive(value)) {
+                attrs[isData || isAria ? key.toLowerCase() : KEYS[key]] = value;
+            }
+            else
+                rejected.push(key);
+        }
+    }
+    if (sink)
+        for (const key of rejected)
+            sink(issue("PROP_REJECTED", path, key));
+    return { attrs, rejected };
+};

package/dist/esm/v3/raw/core/uiSchema.js

@@ -0,0 +1,47 @@
+import { isPlainObject } from "./json";
+/** Flattens `ui:*` keys (prefix removed) and `ui:options` into one object (2.x semantics). */
+export const extractUiSchema = (ui = {}) => {
+    const schema = isPlainObject(ui) ? { ...ui } : {};
+    if (schema.props !== undefined)
+        schema["ui:props"] = { ...(schema["ui:props"] ?? {}), ...(schema.props ?? {}) };
+    const { "ui:options": options = {}, ...rest } = schema;
+    const result = {};
+    for (const key of Object.keys(rest))
+        result[key.replace("ui:", "")] = rest[key];
+    return { ...result, ...(isPlainObject(options) ? options : {}) };
+};
+const fieldsOf = (order) => order.flatMap((entry) => (typeof entry === "string" ? entry : entry?.fields ?? []));
+export const getHiddenProperties = (order, properties) => {
+    if (!Array.isArray(order) || order.includes("*"))
+        return [];
+    const listed = fieldsOf(order);
+    return properties.filter((key) => !listed.includes(key));
+};
+export function orderByUiSchema(order, allProperties) {
+    if (order === undefined || allProperties === undefined)
+        return allProperties;
+    if (!Array.isArray(order))
+        return allProperties;
+    if (!order.includes("*"))
+        return order;
+    const unique = [...new Set(order)];
+    const listed = fieldsOf(unique);
+    const result = [];
+    for (const entry of unique) {
+        if (entry === "*")
+            result.push(...allProperties.filter((p) => !listed.includes(p)));
+        else
+            result.push(entry);
+    }
+    return result;
+}
+export function orderAdditionalProperties(order, values) {
+    if (!Array.isArray(order) || order.length === 0)
+        return values;
+    const relevant = fieldsOf(order).filter((item) => values.includes(item) || item === "*");
+    return orderByUiSchema(relevant, values);
+}
+export const getTitle = ({ title, uiSchema, schema, name }) => uiSchema?.["ui:options"]?.hideTitle
+    ? undefined
+    : title || uiSchema?.["ui:title"] || schema?.title || name?.split(".")[name.split(".").length - 1];
+export const getDescription = ({ description, uiSchema, schema }) => description || uiSchema?.["ui:options"]?.description || uiSchema?.["ui:description"] || schema?.description;

package/dist/esm/v3/raw/dom/bind.js

@@ -0,0 +1,80 @@
+import { controlEvent, delegate, isTextControl } from "./delegate";
+export const bindEvents = (core, target) => {
+    const undelegate = delegate(target, core.records, (on, event, el) => {
+        switch (event.type) {
+            case "input":
+            case "change": {
+                if (!on.change)
+                    break;
+                if (isTextControl(el)) {
+                    // React's onChange: `input` or `change`, once per new value
+                    const value = el.value;
+                    if (core.tracked.get(el) === value)
+                        break;
+                    core.tracked.set(el, value);
+                    core.dispatch(on.change, { value });
+                }
+                else if (event.type === "change" && !core.uploads.handle(on.change, event, el))
+                    core.dispatch(on.change, controlEvent(el));
+                break;
+            }
+            case "focusout": {
+                // React's onBlur is focusout: it also fires on a container when focus leaves one of its controls
+                const related = event.relatedTarget;
+                if (on.focusout)
+                    core.dispatch(on.focusout, { leftContainer: !related || !el.contains(related) });
+                else if (on.blur)
+                    core.dispatch(on.blur, { value: event.target?.value });
+                break;
+            }
+            case "focusin":
+                if (on.focus)
+                    core.dispatch(on.focus);
+                break;
+            case "paste":
+                if (on.paste) {
+                    event.preventDefault();
+                    core.dispatch(on.paste, { value: event.clipboardData?.getData("text")?.trim() ?? "" });
+                }
+                break;
+            case "mousedown":
+                if (on.mousedown)
+                    event.preventDefault();
+                break;
+            case "keydown":
+                // Q-SEL-2: Enter in a search input never submits the form (the document listener still selects).
+                if (on.keydown?.type === "preventEnter" && event.key === "Enter")
+                    event.preventDefault();
+                break;
+            case "click":
+                if (!on.click)
+                    break;
+                if (el.tagName === "A" || on.click.type === "preventDefault")
+                    event.preventDefault();
+                if (on.click.type !== "preventDefault" && !core.uploads.handle(on.click, event, el))
+                    core.dispatch(on.click);
+                break;
+            case "submit":
+                if (on.submit) {
+                    event.preventDefault();
+                    void core.store.submitForm().catch((error) => globalThis.console?.warn?.("fjsf: an unhandled error was caught from submit", error));
+                }
+                break;
+            default: {
+                // dragenter / dragleave / dragover / drop: the files upload
+                const action = on[event.type];
+                if (action)
+                    core.uploads.handle(action, event, el);
+            }
+        }
+    });
+    // 2.x listened on the document while a searchable dropdown was open; one listener per controller here.
+    const doc = target.ownerDocument;
+    // Q-SEL-1: only the open select whose container holds the key's target (the focused one) reacts.
+    const onKey = (e) => [...core.keyActions.values()].filter(({ el }) => el.contains(e.target)).forEach(({ action }) => core.dispatch(action, { keyName: e.key }));
+    doc.addEventListener("keydown", onKey);
+    return () => {
+        undelegate();
+        doc.removeEventListener("keydown", onKey);
+    };
+};

package/dist/esm/v3/raw/dom/build.js

@@ -0,0 +1,23 @@
+import { createFormContext, formField, formShell } from "../model/form";
+import { buildViewNode } from "../model/view";
+import { formShellMarkup } from "../model/view/markup";
+import { toVNode } from "../model/view/toVNode";
+export const buildTree = (schema, uiSchema, state, ui, o, sink) => {
+    const customFields = Object.keys(o.fields ?? {});
+    if (o.mode === "view") {
+        const view = buildViewNode(schema, uiSchema ?? {}, state.values, { customFields, formLocalization: o.formLocalization, sink, fileUploadView: o.fileUploadView });
+        return { tree: formShellMarkup(o.className, [toVNode(view)]) };
+    }
+    const ctx = createFormContext(schema, uiSchema, { values: state.values, errors: state.errors, touched: state.touched, submitting: state.isSubmitting }, {
+        customFields,
+        formLocalization: o.formLocalization ?? {},
+        formOptions: o.formOptions ?? {},
+        locale: o.locale,
+        ui,
+        hideUnmarkedAdditionalProperties: o.hideUnmarkedAdditionalProperties,
+        orderable: !!o.orderable,
+        sink,
+    });
+    const content = formField(ctx, { name: "", schema, ui: uiSchema ?? {} }, []);
+    return { tree: formShell(content, { className: o.className, hideSubmit: !!o.hideSubmit, submitting: state.isSubmitting }), ctx };
+};

package/dist/esm/v3/raw/dom/controller.js

@@ -0,0 +1,83 @@
+import { bindEvents } from "./bind";
+import { createCore } from "./core";
+import { renderCore } from "./render";
+export class FormController {
+    core;
+    unbind;
+    unsubscribe;
+    destroyed = false;
+    constructor(init) {
+        this.core = createCore(init, (core) => renderCore(core, this));
+        const { ui: _ui, ...state } = init.state ?? {};
+        if (Object.keys(state).length)
+            this.core.store.setState(state);
+        this.unsubscribe = this.core.store.subscribe(() => this.core.schedule());
+    }
+    /** The RAW store (the state adapter): values, errors, touched, isSubmitting, submitCount. */
+    get store() {
+        return this.core.store;
+    }
+    /** Draws the form into `target` and binds its events; idempotent per target. */
+    mount(target) {
+        if (this.destroyed || this.core.target === target)
+            return;
+        this.unbind?.();
+        this.core.target = target;
+        this.unbind = bindEvents(this.core, target);
+        this.core.render();
+    }
+    /** New schema / uiSchema / values / options; the form is redrawn (in place). */
+    update(partial) {
+        const core = this.core;
+        if ("schema" in partial)
+            core.schema = partial.schema;
+        if ("uiSchema" in partial)
+            core.uiSchema = partial.uiSchema;
+        if (partial.options)
+            core.options = { ...core.options, ...partial.options };
+        if ("schema" in partial || "uiSchema" in partial)
+            core.reported.clear();
+        if ("values" in partial)
+            core.act(() => core.store.setValues(partial.values, false));
+        core.schedule();
+    }
+    /** Removes every listener (the document one too) and stops the uploads' timers; idempotent. */
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.unbind?.();
+        this.unsubscribe();
+        this.core.uploads.destroy();
+        this.core.emitter.clear();
+        this.core.target = undefined;
+        this.core.keyActions.clear();
+    }
+    getState() {
+        return { ...this.core.store.getState(), ui: this.core.ui };
+    }
+    /** The VNode tree of the last render: what every serialiser draws (toString / toDOM / toReact). */
+    getViewModel() {
+        return this.core.tree;
+    }
+    /** The 2.x error map of `values`; without values, of the current ones, which then become the errors. */
+    async validate(values) {
+        const errors = await this.core.store.validateForm(values);
+        if (values === undefined)
+            this.core.store.setState({ errors });
+        return errors;
+    }
+    /** What the submit button does: touch all, validate, then `submit` and `options.onSubmit` when valid. */
+    submit() {
+        return this.core.store.submitForm().catch((error) => globalThis.console?.warn?.("fjsf: an unhandled error was caught from submit", error));
+    }
+    on(type, handler) {
+        return this.core.emitter.on(type, handler);
+    }
+    off(type, handler) {
+        this.core.emitter.off(type, handler);
+    }
+    once(type, handler) {
+        return this.core.emitter.once(type, handler);
+    }
+}

package/dist/esm/v3/raw/dom/core.js

@@ -0,0 +1,63 @@
+import { createStore } from "../store/createStore";
+import { createEmitter } from "./emitter";
+import { openPicker, runAction } from "./effects";
+import { createUploads } from "./upload";
+const warn = (what) => (error) => globalThis.console?.warn?.(`fjsf: ${what}`, error);
+export const createCore = (init, render) => {
+    const core = {
+        schema: init.schema,
+        uiSchema: init.uiSchema,
+        options: init.options ?? {},
+        ui: init.state?.ui ?? {},
+        emitter: createEmitter(),
+        records: new WeakMap(),
+        tracked: new WeakMap(),
+        keyActions: new Map(),
+        seen: new Set(),
+        reported: new Set(),
+        scrolled: new Map(),
+        slotProps: new Map(),
+        scheduled: false,
+    };
+    core.emit = (event) => core.emitter.emit(event);
+    core.act = (update) => void update().catch(warn("a state update failed"));
+    core.render = () => render(core);
+    core.schedule = () => {
+        if (core.scheduled || !core.target)
+            return;
+        core.scheduled = true;
+        queueMicrotask(() => {
+            core.scheduled = false;
+            core.render();
+        });
+    };
+    core.element = (id) => [...(core.target?.querySelectorAll("[id]") ?? [])].find((el) => el.id === id);
+    core.store = createStore({
+        initialValues: init.values ?? {},
+        validationSchema: core.options.validationSchema,
+        validateOnChange: core.options.validateOnChange,
+        validateOnBlur: core.options.validateOnBlur,
+        onValidated: (errors) => core.emit({ type: "validate", errors }),
+        onSubmit: (values) => {
+            core.emit({ type: "submit", values });
+            return core.options.onSubmit?.(values);
+        },
+    });
+    core.uploads = createUploads({
+        uploads: () => core.options.uploads,
+        values: () => core.store.getState().values,
+        setValue: (path, value) => core.act(() => core.store.setFieldValue(path, value)),
+        rerender: core.schedule,
+        pick: (id) => core.element(id)?.click(),
+    });
+    core.dispatch = (action, event = {}) => runAction({
+        store: core.store,
+        ui: () => core.ui,
+        setUi: (ui) => ((core.ui = ui), core.schedule()),
+        emit: core.emit,
+        askKey: core.options.askKey ?? (() => (typeof globalThis.prompt === "function" ? globalThis.prompt("Give key") : null)),
+        picker: (id) => openPicker(core.element(id)),
+        failed: warn("an action failed"),
+    }, action, event);
+    return core;
+};