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

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

@@ -0,0 +1,39 @@
+import type { Attrs, VChild, VNode } from "../vnode";
+/** A registry component element: the default is the first name of the chain that 2.x defines. */
+export declare const fc: (names: string[], attrs: Attrs, ...children: Array<VChild | VChild[]>) => VNode;
+/** Same, with another tag (2.x `formikAs`: a FieldInput rendered as select / textarea). */
+export declare const fcAs: (tag: string | undefined, names: string[], attrs: Attrs, ...children: Array<VChild | VChild[]>) => VNode;
+/** A styled element that is not a registry key (2.x StringFieldWrapper, ErrorText, ...). */
+export declare const plain: (tag: string, name: string, attrs: Attrs, ...children: Array<VChild | VChild[]>) => VNode;
+/** A 2.x function component in the registry: an override gets `props` (and `children`). */
+export declare const fcComposite: (name: string, props: Record<string, unknown>, content: VChild[] | undefined, ...markup: VChild[]) => VNode;
+export type FormChrome = {
+    path: string;
+    attrs: Attrs;
+    title?: VChild;
+    titleAttrs?: Attrs;
+    description?: VChild;
+    descriptionAttrs?: Attrs;
+    help?: VChild;
+    helpAttrs?: Attrs;
+    required?: boolean;
+    /** `ui:props.disabled` (2.x: FieldWrapper's $isDisabled styles): the wrapper gets aria-disabled. */
+    disabled?: boolean;
+    /** Rendered `FieldInfo` (or null). */
+    info?: VChild;
+    /** Rendered `ErrorMessage` (or null). */
+    error?: VChild;
+};
+/** 2.x Form FieldTemplate. */
+export declare const fieldTemplateMarkup: (c: FormChrome, content: VChild[]) => VNode;
+/** 2.x ObjectFieldTemplate (fieldset + legend). */
+export declare const objectTemplateMarkup: (c: FormChrome, content: VChild[]) => VNode;
+/** 2.x CollapsibleObjectFieldTemplate: a toggle button around the title; ChildrenWrapper is the wrapper chain (2.x). */
+export declare const collapsibleTemplateMarkup: (c: FormChrome, content: VChild[], o: {
+    collapsed: boolean;
+    id: string;
+    ariaLabel: string;
+    icon: string;
+}) => VNode;
+/** 2.x ArrayFieldTemplate: the array names first, then the object/field fallbacks; the title keeps `for`. */
+export declare const arrayTemplateMarkup: (c: FormChrome, items: VChild[]) => VNode;

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

@@ -0,0 +1,9 @@
+import type { VChild } from "../vnode";
+import type { ChildProps } from "./dispatch";
+import type { Trail } from "../../core/trail";
+import type { FormBuildContext } from "./types";
+/** 2.x prepareChildSchema: booleans become {}, a readOnly parent makes the child readOnly. */
+export declare const prepareChildSchema: (child: unknown, parent: any) => Record<string, unknown> | {
+    readOnly: any;
+};
+export declare const objectField: (ctx: FormBuildContext, p: ChildProps, chain: string[], trail?: Trail) => VChild;

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

@@ -0,0 +1,10 @@
+import type { VChild } from "../vnode";
+import type { FormAction, FormBuildContext } from "./types";
+/** 2.x getObjectFieldButton / the ArrayField buttons: `ui:options.<x>Button.{props,content}`, D5-filtered props. */
+export declare const buttonMarkup: (conf: any, names: string | string[], purpose: string, path: string, fallback: string, action: FormAction) => VChild;
+/** Form ObjectFieldSection (a ui:order group); collapsible sections start collapsed (2.x useState(collapsible)). */
+export declare const sectionMarkup: (ctx: FormBuildContext, name: string, entry: {
+    title?: unknown;
+    fields: string[];
+    collapsible?: boolean;
+}, fields: VChild[]) => VChild;

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

@@ -0,0 +1,5 @@
+import type { VChild } from "../vnode";
+import type { FieldProps } from "./chrome";
+import type { FormBuildContext } from "./types";
+export declare const searchableSelectField: (ctx: FormBuildContext, p: FieldProps) => VChild;
+export declare const searchableMultiTagField: (ctx: FormBuildContext, p: FieldProps) => VChild;

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

@@ -0,0 +1,14 @@
+import type { TemplateHost } from "../host";
+import type { VChild, VNode } from "../vnode";
+import type { FieldProps } from "./chrome";
+import type { FormBuildContext } from "./types";
+/** The 2.x template props: the field props plus the data-* props the field passed. */
+export declare const templateProps: (p: FieldProps) => {
+    "data-fjsf-hidden"?: string | undefined;
+    "data-fjsf-kind"?: string | undefined;
+    required?: boolean | undefined;
+    name: string;
+    schema: any;
+    uiSchema: any;
+};
+export declare const templated: (_ctx: FormBuildContext, template: TemplateHost["template"], p: FieldProps, markup: VNode, children: VChild[], extra?: Partial<TemplateHost>) => VNode;

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

@@ -0,0 +1,179 @@
+import type { Definitions } from "../../core/json";
+import type { IssueSink } from "../../core/issues";
+/** How a control's DOM value becomes a stored value (2.x: formik Field + the field's own onChange). */
+export type Parse = "text" | "number" | "checkbox" | "enum" | "multi" | "radio";
+export type FormAction = {
+    type: "set";
+    path: string;
+    parse: Parse;
+    consts?: unknown[];
+} | {
+    type: "touch";
+    path: string;
+} | {
+    type: "toggle";
+    path: string;
+} | {
+    type: "submit";
+} | {
+    type: "arrayAdd";
+    path: string;
+    item: unknown;
+} | {
+    type: "arrayRemove";
+    path: string;
+    index: number;
+} | {
+    type: "arrayMove";
+    path: string;
+    from: number;
+    to: number;
+} | {
+    type: "propertyAdd";
+    path: string;
+    order: string[];
+    item: unknown;
+} | {
+    type: "propertyRemove";
+    path: string;
+    key: string;
+    order: string[];
+} | {
+    type: "propertyMove";
+    path: string;
+    order: string[];
+    next: string[];
+} | {
+    type: "collapse";
+    id: string;
+    collapsed: boolean;
+} | {
+    type: "anyType";
+    path: string;
+} | {
+    type: "info";
+    id: string;
+    display: "tooltip" | "inline";
+} | {
+    type: "choice";
+    path: string;
+    value: unknown;
+    multi: boolean;
+} | {
+    type: "dateText";
+    path: string;
+} | {
+    type: "dateCommit";
+    path: string;
+    rules: DateCommitRules;
+    locked: boolean;
+    native?: boolean;
+} | {
+    type: "datePicker";
+    id: string;
+    locked: boolean;
+} | {
+    type: "searchInput";
+    path: string;
+    perPage: number;
+} | {
+    type: "searchOpen";
+    path: string;
+} | {
+    type: "searchLeave";
+    path: string;
+} | {
+    type: "searchClear";
+    path: string;
+} | {
+    type: "searchMore";
+    path: string;
+    perPage: number;
+} | {
+    type: "searchSelect";
+    path: string;
+    value: unknown;
+    title: string;
+} | {
+    type: "searchKey";
+    path: string;
+    items: Array<{
+        type: "searchSelect";
+        path: string;
+        value: unknown;
+        title: string;
+    }>;
+    open: boolean;
+} | {
+    type: "searchText";
+    path: string;
+} | {
+    type: "tagAdd";
+    path: string;
+    value: unknown;
+} | {
+    type: "tagRemove";
+    path: string;
+    value: unknown;
+} | {
+    type: "preventDefault";
+} | {
+    type: "searchActive";
+    path: string;
+    index: number;
+} | {
+    type: "preventEnter";
+};
+export type DateCommitRules = {
+    locale: string;
+    min?: string;
+    max?: string;
+    invalid: string;
+    outOfRange: string;
+    order: "DMY" | "MDY";
+};
+/** UI state the host keeps per mount (not form values): collapse, AnyField types, open inline infos. */
+export type FormUiState = {
+    collapsed?: Record<string, boolean>;
+    /** Typed, uncommitted text of a control (DateField display, searchable search term). */
+    text?: Record<string, string>;
+    /** Searchable: dropdown open, how many options are listed, the keyboard-active option. */
+    open?: Record<string, boolean>;
+    shown?: Record<string, number>;
+    active?: Record<string, number>;
+    anyTypes?: Record<string, string>;
+    infoOpen?: Record<string, boolean>;
+};
+/** A node that appeared in this render: its default is applied once per appearance (§2.7a). */
+export type Appearance = {
+    path: string;
+    schema: any;
+    forceDefaultValue: boolean;
+};
+export type FormBuildContext = {
+    values: unknown;
+    errors: unknown;
+    touched: unknown;
+    submitting: boolean;
+    customFields: string[];
+    definitions: Definitions;
+    defs: Definitions;
+    uiDefinitions: any;
+    sink: IssueSink;
+    formLocalization?: any;
+    formOptions?: any;
+    /** The host's default locale (React: navigator.language); RAW reads no browser globals. */
+    locale?: string;
+    ui: FormUiState;
+    hideUnmarkedAdditionalProperties: boolean;
+    /** `onAdditionalPropertyOrderChange` is given: additional properties get up/down buttons. */
+    orderable: boolean;
+    /** Collected while building: defaults to apply and keys to prune (React applies them in an effect). */
+    appeared: Appearance[];
+    prune: Array<{
+        path: string;
+        keys: string[];
+    }>;
+    /** AnyField types guessed in this render (no type in the UI state yet): the host keeps them (2.x useState). */
+    anyGuesses: Record<string, string>;
+};

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

@@ -0,0 +1,28 @@
+import type { VChild, VNode } from "../vnode";
+import type { FieldProps } from "./chrome";
+import type { FormBuildContext } from "./types";
+export type FileState = {
+    value: unknown;
+    uploadedFile: {
+        name?: unknown;
+    } | null;
+    progress: number;
+};
+export type UploadedFile = {
+    name: string;
+    id: string | null;
+    progressId: string;
+    mimeType?: string;
+    size?: number;
+};
+export type FilesState = {
+    value: unknown;
+    files: UploadedFile[];
+    progress: Record<string, number>;
+    dragging: boolean;
+};
+/** 2.x FilesUploadField: the files of a stored value (uploaded, so progress 100). */
+export declare const filesOf: (value: unknown) => UploadedFile[];
+export declare const fileUploadMarkup: (ctx: FormBuildContext, p: FieldProps, s: FileState) => VNode;
+export declare const filesLocalization: (ctx: FormBuildContext, ui: any) => any;
+export declare const filesUploadMarkup: (ctx: FormBuildContext, p: FieldProps, s: FilesState) => VChild;

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

@@ -0,0 +1,46 @@
+import type { ChildField } from "./view/types";
+import type { VChild } from "./vnode";
+/** A field the host provides (custom field name, overridden built-in, or a component `ui:field`). */
+export type FieldHost = {
+    kind: "field";
+    field: string;
+    props: Record<string, unknown>;
+    chain?: string[];
+};
+/** A template boundary: `props` are the 2.x template props, `children` the content without the template chrome. */
+export type TemplateHost = {
+    kind: "template";
+    template: "FieldTemplate" | "ObjectFieldTemplate" | "ArrayFieldTemplate" | "CollapsibleObjectFieldTemplate";
+    /** `ui:template`: looked up first, as in 2.x. */
+    override?: string;
+    props: Record<string, unknown>;
+    children: VChild[];
+    /** ArrayFieldTemplate: the item values and the rendered items, for `items` / `renderItem`. */
+    items?: unknown[];
+    itemNodes?: VChild[];
+    /** ObjectFieldTemplate: the 2.x `<SchemaField>` props per child, and the $ref chain they continue. */
+    childFields?: ChildField[];
+    chain?: string[];
+};
+/**
+ * A registry component (`registry.components`, CM-a). `names` is the 2.x lookup chain
+ * (`components.A ?? components.B`). Composite components get `props` instead of the
+ * element's attributes.
+ */
+export type ComponentHost = {
+    kind: "component";
+    names: string[];
+    props?: Record<string, unknown>;
+    children?: VChild[];
+};
+/** Where a React template puts its React children. */
+export type HoleHost = {
+    kind: "hole";
+    name?: string;
+};
+/** A host value shown as is by its own renderer (a React element `ui:title`); toString shows nothing. */
+export type ValueHost = {
+    kind: "value";
+    value: unknown;
+};
+export type Host = FieldHost | TemplateHost | ComponentHost | HoleHost | ValueHost;

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

@@ -0,0 +1 @@
+export declare const STYLED_CHAINS: Readonly<Record<string, readonly string[]>>;

package/dist/types/v3/raw/model/view/build.d.ts

@@ -0,0 +1,21 @@
+import type { Definitions, Schema } from "../../core/json";
+import type { IssueSink } from "../../core/issues";
+import type { FileUploadView } from "../../core/policies/fileUploadView";
+import type { Trail } from "../../core/trail";
+import type { FieldKind, ViewNode, ViewOptions } from "./types";
+export type BuildContext = Required<Pick<ViewOptions, "customFields">> & Pick<ViewOptions, "formLocalization"> & {
+    values: unknown;
+    sink: IssueSink;
+    definitions: Definitions;
+    defs: Definitions;
+    uiDefinitions: any;
+    fileUploadView: FileUploadView;
+};
+/** 2.x FormView SchemaField: resolve refs, pick the field (ui:field, then type), render it. */
+export declare const schemaField: (name: string, given: Schema | undefined, givenUi: any, ctx: BuildContext, kindProp?: FieldKind, chain?: string[], trail?: Trail) => ViewNode;
+/** One built-in field by name (2.x `FormViewFields.X`), without the SchemaField dispatch. */
+export declare const componentField: (component: string, name: string, schema: Schema, ui: any, ctx: BuildContext, kindProp?: FieldKind, nextChain?: string[], trail?: Trail) => ViewNode;
+/** The build context for a form whose root schema/uiSchema carry the definitions. */
+export declare const createViewContext: (schema: Schema | undefined, uiSchema: any, values: unknown, options?: ViewOptions) => BuildContext;
+/** Root entry: the whole read-only view-model of a form. */
+export declare const buildViewNode: (schema: Schema, uiSchema: any, values: unknown, options?: ViewOptions) => ViewNode;

package/dist/types/v3/raw/model/view/fields.d.ts

@@ -0,0 +1,31 @@
+import type { Schema } from "../../core/json";
+import type { ViewNode, FieldKind } from "./types";
+import type { BuildContext } from "./build";
+import type { IssueSink } from "../../core/issues";
+/** Instrumentation attributes of a field wrapper (2.x getInstrumentationAttributes; FormView never sets required/hidden). */
+export declare const fieldAttrs: (name: string, kind: FieldKind | undefined, schema: Schema | undefined) => Record<string, string>;
+/** 2.x templates spread `ui:props.{wrapper,title,description}`; v3 keeps the D5 allowlist of them. */
+export declare const elementProps: (ui: any, path: string, sink?: IssueSink) => {
+    wrapperAttrs: Record<string, string | number | boolean>;
+    titleAttrs: Record<string, string | number | boolean>;
+    descriptionAttrs: Record<string, string | number | boolean>;
+};
+export declare const chrome: (name: string, kind: FieldKind | undefined, schema: Schema | undefined, ui: any, sink?: IssueSink) => {
+    path: string;
+    attrs: Record<string, string>;
+    titleAttrs: Record<string, string | number | boolean>;
+    descriptionAttrs: Record<string, string | number | boolean>;
+    title: string | import("../vnode").VNode | undefined;
+    description: string | import("../vnode").VNode | undefined;
+    schema: import("json-schema").JSONSchema7 | undefined;
+    ui: any;
+};
+/** StringField / NumberField / DateField / SearchableSelectField: the value as text (enum consts as titles). */
+export declare const textField: (name: string, schema: Schema, ui: any, kind: FieldKind | undefined, ctx: BuildContext) => ViewNode;
+export declare const textAreaField: (name: string, schema: Schema, ui: any, ctx: BuildContext) => ViewNode;
+/** BooleanField / RadioField / ToggleField: a check mark and a label. */
+export declare const booleanField: (name: string, schema: Schema, ui: any, kind: FieldKind, ctx: BuildContext) => ViewNode;
+/** MultipleChoiceField: every option with a check mark when selected (`onlyShowSelected` filters). */
+export declare const choicesField: (name: string, schema: Schema, ui: any, ctx: BuildContext) => ViewNode;
+export declare const nullField: (name: string, schema: Schema, ui: any, kind?: FieldKind) => ViewNode;
+export declare const slotField: (name: string, schema: Schema, ui: any, field: string, chain?: string[]) => ViewNode;

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

@@ -0,0 +1,6 @@
+import type { Schema } from "../../core/json";
+import type { ViewOptions } from "./types";
+import { buildViewNode } from "./build";
+export declare const renderViewToString: (schema: Schema, uiSchema: any, values: unknown, options?: ViewOptions) => string;
+export { buildViewNode };
+export type { ViewNode, ViewOptions } from "./types";

package/dist/types/v3/raw/model/view/markup.d.ts

@@ -0,0 +1,39 @@
+import type { Attrs, VChild, VNode } from "../vnode";
+/** 2.x FormView styled primitives in `registry.components` and their tags. */
+export declare const VIEW_PRIMITIVES: Readonly<Record<string, string>>;
+/** Override-only keys: `undefined` by default, read before their fallback (2.x getComponents). */
+export declare const VIEW_OVERRIDE_ONLY: readonly ["ArrayFieldTemplateDescription", "ArrayFieldTemplateTitle", "ArrayFieldTemplateWrapper", "ObjectFieldTemplateDescription"];
+export declare const viewClass: (name: string) => string;
+/** A registry component element; its default is the first name in the chain that has one. */
+export declare const component: (names: string[], attrs: Attrs, ...children: Array<VChild | VChild[]>) => VNode;
+/** A composite registry component (2.x function components): an override gets `props` (and `children`). */
+export declare const composite: (name: string, props: Record<string, unknown>, content: VChild[] | undefined, ...markup: VChild[]) => VNode;
+export type Chrome = {
+    path: string;
+    attrs: Attrs;
+    title?: VChild;
+    description?: VChild;
+    titleAttrs?: Attrs;
+    descriptionAttrs?: Attrs;
+};
+/** FormView FieldTemplate: wrapper, title <label for>, description, content. */
+export declare const fieldTemplateMarkup: (c: Chrome, content: VChild[]) => VNode;
+export declare const objectTemplateMarkup: (c: Chrome, content: VChild[]) => VNode;
+/** 2.x ArrayFieldTemplate: array names first, then the object/field fallbacks; the title keeps `for`. */
+export declare const arrayTemplateMarkup: (c: Chrome, content: VChild[]) => VNode;
+/** ObjectFieldSection (a `ui:order` group): fieldset + legend. */
+export declare const sectionMarkup: (title: string, content: VChild[]) => VNode;
+/** The root: FormWrapper > components.Form. */
+export declare const formShellMarkup: (className: string | undefined, content: VChild[]) => VNode;
+/** The check mark FormView draws for a selected value (2.x: react-icons FaCheck, an <svg>). */
+export declare const checkIconMarkup: (className?: string) => VNode;
+/** BooleanFieldValue's default markup. */
+export declare const booleanValueMarkup: (selected: boolean, label: string) => VNode;
+export type ChoiceOption = {
+    value: string;
+    title: string;
+    selected: boolean;
+};
+/** MultipleChoiceFieldValue's default markup. */
+/** `style`: the ui:style layout keyword (2.x getStyle on the container). */
+export declare const choicesValueMarkup: (options: ChoiceOption[], style?: unknown) => VNode;

package/dist/types/v3/raw/model/view/toVNode.d.ts

@@ -0,0 +1,3 @@
+import type { VChild } from "../vnode";
+import type { ViewNode } from "./types";
+export declare const toVNode: (node: ViewNode) => VChild;

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

@@ -0,0 +1,109 @@
+import type { Schema } from "../../core/json";
+import type { VNode } from "../vnode";
+import type { IssueSink } from "../../core/issues";
+import type { FileUploadView } from "../../core/policies/fileUploadView";
+export type FieldKind = "string" | "number" | "boolean" | "null" | "object" | "array" | "enum" | "multi-enum" | "date" | "textarea" | "radio" | "toggle" | "file" | "files" | "searchable" | "searchable-multi" | "any" | "custom" | "error";
+type Base = {
+    path: string;
+    /** data-fjsf-* attributes, computed once here (frozen + 2.0.4 instrumentation). */
+    attrs: Record<string, string>;
+    title?: string | VNode;
+    description?: string | VNode;
+    /** `ui:props.title` / `.description` after the D5 allowlist (the wrapper's are in `attrs`). */
+    titleAttrs?: Record<string, string | number | boolean>;
+    descriptionAttrs?: Record<string, string | number | boolean>;
+    /** The resolved schema and uiSchema, the 2.x props of templates and host fields. */
+    schema?: Schema;
+    ui?: any;
+};
+export type ArrayItem = {
+    node: ViewNode;
+} | {
+    keyword?: string;
+    text: string;
+};
+export type ViewNode = (Base & {
+    render: "object";
+    children: ViewChild[];
+    childFields: ChildField[];
+    chain: string[];
+}) | (Base & {
+    render: "text";
+    keyword?: string;
+    text: string;
+}) | (Base & {
+    render: "textarea";
+    text: string;
+}) | (Base & {
+    render: "boolean";
+    selected: boolean;
+    label: string;
+    value: unknown;
+    uiLabel?: string;
+    selectedLabel?: string;
+    notSelectedLabel?: string;
+}) | (Base & {
+    render: "choices";
+    options: Array<{
+        value: string;
+        title: string;
+        selected: boolean;
+        const: unknown;
+    }>;
+}) | (Base & {
+    render: "array";
+    items: ArrayItem[];
+    values: unknown[];
+}) | (Base & {
+    render: "any";
+    type: string;
+    child: ViewNode;
+}) | (Base & {
+    render: "null";
+}) | (Base & {
+    render: "slot";
+    field: string;
+    chain: string[];
+}) | {
+    render: "unsupported";
+    text: string;
+} | {
+    render: "plain";
+    text: string;
+} | {
+    render: "none";
+};
+/** What 2.x ObjectField passed to `<SchemaField>` per property (or per `ui:order` section). */
+export type ChildProps = {
+    key: string;
+    name: string;
+    schema: unknown;
+    uiSchema: unknown;
+};
+export type ChildField = ChildProps | {
+    section: string;
+    fields: ChildProps[];
+};
+export type SectionNode = {
+    render: "section";
+    title: string;
+    children: ViewNode[];
+};
+export type ViewChild = ViewNode | SectionNode;
+export type ViewOptions = {
+    /** Host-provided custom field names (React components in the React layer). RAW renders a slot. */
+    customFields?: string[];
+    /** 2.x `formLocalization` (BooleanField selected/notSelected labels). */
+    formLocalization?: {
+        fields?: {
+            BooleanField?: {
+                selectedLabel?: string;
+                notSelectedLabel?: string;
+            };
+        };
+    };
+    sink?: IssueSink;
+    /** Q-FV-2: file upload fields; defaults to FILE_UPLOAD_VIEW. */
+    fileUploadView?: FileUploadView;
+};
+export {};

package/dist/types/v3/raw/model/view/values.d.ts

@@ -0,0 +1,10 @@
+import type { VNode } from "../vnode";
+/** Text React renders for a child value. */
+export declare const reactText: (value: unknown) => string;
+/** Attribute value React writes for a data-* attribute, or undefined (omitted). */
+export declare const reactAttr: (value: unknown) => string | undefined;
+/** 2.x getTitle (getTitleAndDescription.ts) for a field: ui:title > title > last path segment. */
+/** A uiSchema text (help, info content): a string, a React element kept for the host, or undefined. */
+export declare const textOf: (value: unknown) => string | VNode | undefined;
+export declare const titleOf: (uiSchema: any, schema: any, name: string) => string | VNode | undefined;
+export declare const descriptionOf: (uiSchema: any, schema: any) => string | VNode | undefined;

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

@@ -0,0 +1,24 @@
+import type { Host } from "./host";
+export type AttrValue = string | number | boolean | null | undefined;
+export type Attrs = Record<string, AttrValue>;
+export type VChild = VNode | string | number | null | undefined | false;
+/**
+ * `on`: declarative event descriptors (event name -> action data), never functions. toString
+ * ignores them; toReact / toDOM bind them to the state (S4 Form, S6 RAW DOM).
+ */
+export type VNode = {
+    tag: string;
+    attrs: Attrs;
+    children: VChild[];
+    host?: Host;
+    on?: Record<string, unknown>;
+};
+export declare const h: (tag: string, attrs?: Attrs, ...children: Array<VChild | VChild[]>) => VNode;
+/** The same node, marked with the extension point that produced it (ignored by toString). */
+export declare const withHost: (node: VNode, host: Host) => VNode;
+/** The same node with event descriptors (merged over existing ones). */
+export declare const withOn: (node: VNode, on: Record<string, unknown>) => VNode;
+/** Where a React template puts its children; serialises to nothing. */
+export declare const hole: (name?: string) => VNode;
+/** Joins class names, skipping empty parts. */
+export declare const cx: (...names: Array<string | false | undefined>) => string | undefined;

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

@@ -0,0 +1,2 @@
+export { SANITIZER_UNAVAILABLE, SanitizerUnavailableError, STRICT_CONFIG, sanitizeHtml, setSanitizerWindow, } from "./sanitizeHtml";
+export type { SanitizeHtmlOptions } from "./sanitizeHtml";

package/dist/types/v3/raw/sanitize/sanitizeHtml.d.ts

@@ -0,0 +1,30 @@
+import type { Config } from "dompurify";
+import createDOMPurify from "dompurify";
+/** Code of the error thrown when there is no DOM to sanitise with. */
+export declare const SANITIZER_UNAVAILABLE = "SANITIZER_UNAVAILABLE";
+export declare class SanitizerUnavailableError extends Error {
+    readonly code = "SANITIZER_UNAVAILABLE";
+    constructor();
+}
+export declare const STRICT_CONFIG: Readonly<Config>;
+type WindowLike = Parameters<typeof createDOMPurify>[0];
+export type SanitizeHtmlOptions = {
+    window?: WindowLike;
+};
+/**
+ * Registers the DOM window `sanitizeHtml` uses where there is no global one (Node).
+ *
+ * Remote `http(s)` images are kept by policy. In a browser that is a tracking
+ * pixel; if you sanitise on the server and render the result in a headless
+ * browser (e.g. PDF generation), it is also an egress/SSRF vector: apply an
+ * egress policy or request interception there (plan §8.4).
+ */
+export declare const setSanitizerWindow: (window: WindowLike | undefined) => void;
+/**
+ * Sanitises untrusted HTML with the strict config. Isomorphic: uses the
+ * browser's window, or one supplied for Node. With no usable window it
+ * throws SanitizerUnavailableError (code SANITIZER_UNAVAILABLE): fail closed,
+ * never pass the input through.
+ */
+export declare const sanitizeHtml: (html: string, options?: SanitizeHtmlOptions) => string;
+export {};

package/dist/types/v3/raw/serialize/toDOM.d.ts

@@ -0,0 +1,14 @@
+import type { VChild, VNode } from "../model/vnode";
+export type DomEnv = {
+    doc: Document;
+    /** The `on` record of every element drawn (event delegation). */
+    on: WeakMap<Element, Record<string, unknown>>;
+    /** Host-marked node: return VChildren to draw instead (e.g. a host field), or undefined for the default markup. */
+    host?: (node: VNode) => VChild[] | undefined;
+    /** Called for every element drawn with its node (the controller's post-render work: slots, active options). */
+    drawn?: (el: Element, node: VNode) => void;
+};
+/** Makes `parent`'s children match `children` (in place where tags match). */
+export declare const patchChildren: (parent: Element, children: VChild[], env: DomEnv, svg?: boolean) => void;
+/** Draws `node` as the only content of `target`. */
+export declare const toDOM: (target: Element, node: VChild, env: DomEnv) => void;

package/dist/types/v3/raw/serialize/toString.d.ts

@@ -0,0 +1,4 @@
+import type { VNode } from "../model/vnode";
+export declare const escapeText: (text: string) => string;
+export declare const escapeAttr: (text: string) => string;
+export declare const toString: (node: VNode, selected?: Set<string>) => string;