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

package/dist/cjs/v3/raw/model/view/fields.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slotField = exports.nullField = exports.choicesField = exports.booleanField = exports.textAreaField = exports.textField = exports.chrome = exports.elementProps = exports.fieldAttrs = void 0;
+const enums_1 = require("../../core/enums");
+const paths_1 = require("../../core/paths");
+const schemaType_1 = require("../../core/schemaType");
+const en_1 = require("../../i18n/en");
+const json_1 = require("../../core/json");
+const uiProps_1 = require("../../core/uiProps");
+const uiSchema_1 = require("../../core/uiSchema");
+const values_1 = require("./values");
+/** Instrumentation attributes of a field wrapper (2.x getInstrumentationAttributes; FormView never sets required/hidden). */
+const fieldAttrs = (name, kind, schema) => ({
+    "data-fjsf-path": name,
+    ...(kind ? { "data-fjsf-kind": kind } : {}),
+    ...(schema?.readOnly ? { "data-fjsf-readonly": "true" } : {}),
+});
+exports.fieldAttrs = fieldAttrs;
+/** 2.x templates spread `ui:props.{wrapper,title,description}`; v3 keeps the D5 allowlist of them. */
+const elementProps = (ui, path, sink) => {
+    const props = (0, uiSchema_1.extractUiSchema)(ui).props;
+    const pick = (key) => ((0, json_1.isPlainObject)(props) && props[key] !== undefined ? (0, uiProps_1.filterUiProps)(props[key], path, sink).attrs : {});
+    return { wrapperAttrs: pick("wrapper"), titleAttrs: pick("title"), descriptionAttrs: pick("description") };
+};
+exports.elementProps = elementProps;
+const chrome = (name, kind, schema, ui, sink) => {
+    const { wrapperAttrs, titleAttrs, descriptionAttrs } = (0, exports.elementProps)(ui, name, sink);
+    return {
+        path: name,
+        // 2.x order: the wrapper props first, the library's instrumentation wins.
+        attrs: { ...wrapperAttrs, ...(0, exports.fieldAttrs)(name, kind, schema) },
+        titleAttrs,
+        descriptionAttrs,
+        title: (0, values_1.titleOf)(ui, schema, name),
+        description: (0, values_1.descriptionOf)(ui, schema),
+        schema,
+        ui,
+    };
+};
+exports.chrome = chrome;
+const enumsOf = (schema, ctx, name) => (0, enums_1.getEnums)({ schema }, ctx.sink, name);
+/** StringField / NumberField / DateField / SearchableSelectField: the value as text (enum consts as titles). */
+const textField = (name, schema, ui, kind, ctx) => {
+    let value = (0, paths_1.getIn)(ctx.values, name);
+    const enums = enumsOf(schema, ctx, name);
+    if (enums !== undefined)
+        value = enums.values.find((e) => e.const === value)?.title ?? value;
+    const t = (0, schemaType_1.getSchemaType)(schema);
+    const resolvedKind = kind ?? (enums !== undefined ? "enum" : t === "number" || t === "integer" ? "number" : "string");
+    return { render: "text", ...(0, exports.chrome)(name, resolvedKind, schema, ui, ctx.sink), text: (0, values_1.reactText)(value), keyword: (0, values_1.reactAttr)(value) };
+};
+exports.textField = textField;
+const textAreaField = (name, schema, ui, ctx) => ({
+    render: "textarea",
+    ...(0, exports.chrome)(name, "textarea", schema, ui, ctx.sink),
+    text: (0, values_1.reactText)((0, paths_1.getIn)(ctx.values, name)),
+});
+exports.textAreaField = textAreaField;
+/** BooleanField / RadioField / ToggleField: a check mark and a label. */
+const booleanField = (name, schema, ui, kind, ctx) => {
+    const value = (0, paths_1.getIn)(ctx.values, name);
+    const raw = (0, uiSchema_1.extractUiSchema)(ui).label;
+    const label = raw !== null && typeof raw === "object" ? (value === true ? raw.true : value === false ? raw.false : undefined) : typeof raw === "string" ? raw : undefined;
+    const loc = ctx.formLocalization?.fields?.BooleanField ?? {};
+    const selected = value === true;
+    const fallback = selected ? loc.selectedLabel ?? en_1.en["view.boolean.selected"] : loc.notSelectedLabel ?? en_1.en["view.boolean.notSelected"];
+    return {
+        render: "boolean",
+        ...(0, exports.chrome)(name, kind, schema, ui, ctx.sink),
+        selected,
+        label: (0, values_1.reactText)(label !== undefined ? label : fallback),
+        value,
+        uiLabel: label,
+        selectedLabel: loc.selectedLabel,
+        notSelectedLabel: loc.notSelectedLabel,
+    };
+};
+exports.booleanField = booleanField;
+/** MultipleChoiceField: every option with a check mark when selected (`onlyShowSelected` filters). */
+const choicesField = (name, schema, ui, ctx) => {
+    const value = (0, paths_1.getIn)(ctx.values, name);
+    const enums = enumsOf(schema, ctx, name);
+    const all = (enums?.values ?? []).map((e) => ({
+        value: (0, values_1.reactAttr)(e?.const) ?? "",
+        title: (0, values_1.reactText)(e?.title),
+        selected: Array.isArray(value) ? value.includes(e?.const) : value === e?.const,
+        const: e?.const,
+    }));
+    const onlySelected = (0, uiSchema_1.extractUiSchema)(ui).onlyShowSelected;
+    const kind = enums?.type === enums_1.EnumsTypes.MULTI_SELECT ? "multi-enum" : "enum";
+    return { render: "choices", ...(0, exports.chrome)(name, kind, schema, ui, ctx.sink), options: onlySelected ? all.filter((o) => o.selected) : all };
+};
+exports.choicesField = choicesField;
+const nullField = (name, schema, ui, kind = "null") => ({ render: "null", ...(0, exports.chrome)(name, kind, schema, ui) });
+exports.nullField = nullField;
+const slotField = (name, schema, ui, field, chain = []) => ({
+    render: "slot",
+    ...(0, exports.chrome)(name, "custom", schema, ui),
+    field,
+    chain,
+});
+exports.slotField = slotField;

package/dist/cjs/v3/raw/model/view/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildViewNode = exports.renderViewToString = void 0;
+const toString_1 = require("../../serialize/toString");
+const vnode_1 = require("../vnode");
+const build_1 = require("./build");
+Object.defineProperty(exports, "buildViewNode", { enumerable: true, get: function () { return build_1.buildViewNode; } });
+const toVNode_1 = require("./toVNode");
+const renderViewToString = (schema, uiSchema, values, options = {}) => (0, toString_1.toString)((0, vnode_1.h)("div", { class: "fjsf-view-FormWrapper" }, (0, vnode_1.h)("div", { class: "fjsf-view-Form" }, (0, toVNode_1.toVNode)((0, build_1.buildViewNode)(schema, uiSchema, values, options)))));
+exports.renderViewToString = renderViewToString;

package/dist/cjs/v3/raw/model/view/markup.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.choicesValueMarkup = exports.booleanValueMarkup = exports.checkIconMarkup = exports.formShellMarkup = exports.sectionMarkup = exports.arrayTemplateMarkup = exports.objectTemplateMarkup = exports.fieldTemplateMarkup = exports.composite = exports.component = exports.viewClass = exports.VIEW_OVERRIDE_ONLY = exports.VIEW_PRIMITIVES = void 0;
+const choiceStyle_1 = require("../../core/choiceStyle");
+const vnode_1 = require("../vnode");
+/** 2.x FormView styled primitives in `registry.components` and their tags. */
+exports.VIEW_PRIMITIVES = {
+    ArrayFieldItem: "div", BooleanFieldWrapper: "div", EJSFieldValue: "div", FieldDescription: "div", FieldTitle: "label",
+    FieldWrapper: "div", Form: "div", Icon: "div", MultipleChoiceFieldWrapper: "div", ObjectFieldSectionTitle: "legend",
+    ObjectFieldSectionWrapper: "fieldset", ObjectFieldTemplateTitle: "div", ObjectFieldTemplateWrapper: "div",
+    StringFieldValue: "div", TextAreaValue: "div",
+};
+/** Override-only keys: `undefined` by default, read before their fallback (2.x getComponents). */
+exports.VIEW_OVERRIDE_ONLY = ["ArrayFieldTemplateDescription", "ArrayFieldTemplateTitle", "ArrayFieldTemplateWrapper", "ObjectFieldTemplateDescription"];
+const viewClass = (name) => `fjsf-view-${name}`;
+exports.viewClass = viewClass;
+/** A registry component element; its default is the first name in the chain that has one. */
+const component = (names, attrs, ...children) => {
+    const name = names.find((n) => n in exports.VIEW_PRIMITIVES);
+    // A `className` from ui:props joins the library class (2.x: styled-components merged it).
+    const cls = typeof attrs.class === "string" && attrs.class ? `${(0, exports.viewClass)(name)} ${attrs.class}` : (0, exports.viewClass)(name);
+    const { class: _own, ...rest } = attrs;
+    return (0, vnode_1.withHost)((0, vnode_1.h)(exports.VIEW_PRIMITIVES[name], { class: cls, ...rest }, ...children), { kind: "component", names });
+};
+exports.component = component;
+/** A composite registry component (2.x function components): an override gets `props` (and `children`). */
+const composite = (name, props, content, ...markup) => (0, vnode_1.withHost)((0, vnode_1.h)("#fragment", {}, ...markup), { kind: "component", names: [name], props, ...(content ? { children: content } : {}) });
+exports.composite = composite;
+/** FormView FieldTemplate: wrapper, title <label for>, description, content. */
+const fieldTemplateMarkup = (c, content) => (0, exports.component)(["FieldWrapper"], c.attrs, c.title ? (0, exports.component)(["FieldTitle"], { ...c.titleAttrs, for: c.path }, c.title) : null, c.description ? (0, exports.component)(["FieldDescription"], { ...c.descriptionAttrs }, c.description) : null, ...content);
+exports.fieldTemplateMarkup = fieldTemplateMarkup;
+const objectTemplateMarkup = (c, content) => (0, exports.component)(["ObjectFieldTemplateWrapper"], c.attrs, c.title ? (0, exports.component)(["ObjectFieldTemplateTitle"], { ...c.titleAttrs }, c.title) : null, c.description ? (0, exports.component)(["ObjectFieldTemplateDescription", "FieldDescription"], { ...c.descriptionAttrs }, c.description) : null, ...content);
+exports.objectTemplateMarkup = objectTemplateMarkup;
+/** 2.x ArrayFieldTemplate: array names first, then the object/field fallbacks; the title keeps `for`. */
+const arrayTemplateMarkup = (c, content) => (0, exports.component)(["ArrayFieldTemplateWrapper", "ObjectFieldTemplateWrapper"], c.attrs, c.title ? (0, exports.component)(["ArrayFieldTemplateTitle", "ObjectFieldTemplateTitle"], { ...c.titleAttrs, for: c.path }, c.title) : null, c.description ? (0, exports.component)(["ArrayFieldTemplateDescription", "FieldDescription"], { ...c.descriptionAttrs }, c.description) : null, ...content);
+exports.arrayTemplateMarkup = arrayTemplateMarkup;
+/** ObjectFieldSection (a `ui:order` group): fieldset + legend. */
+const sectionMarkup = (title, content) => (0, exports.composite)("ObjectFieldSection", { title }, content, (0, exports.component)(["ObjectFieldSectionWrapper"], { "data-fjsf-section": title }, (0, exports.component)(["ObjectFieldSectionTitle"], {}, title), ...content));
+exports.sectionMarkup = sectionMarkup;
+/** The root: FormWrapper > components.Form. */
+const formShellMarkup = (className, content) => (0, vnode_1.h)("div", { class: "fjsf-view-FormWrapper" }, (0, exports.component)(["Form"], className ? { class: className } : {}, ...content));
+exports.formShellMarkup = formShellMarkup;
+// MultipleChoice* are the Form components 2.x FormView reuses (styled(RadioField*) chains).
+const CHOICE = {
+    container: "fjsf-CommonCheckboxStyles fjsf-RadioFieldContainer fjsf-MultipleChoiceFieldContainer",
+    element: "fjsf-RadioFieldElement fjsf-MultipleChoiceFieldElement",
+    label: "fjsf-RadioFieldLabel fjsf-MultipleChoiceFieldLabel",
+};
+/** The check mark FormView draws for a selected value (2.x: react-icons FaCheck, an <svg>). */
+const checkIconMarkup = (className = (0, exports.viewClass)("SelectedIcon")) => (0, vnode_1.h)("svg", { class: className, viewBox: "0 0 512 512", "aria-hidden": "true", focusable: "false" }, (0, vnode_1.h)("path", { d: "M173.9 439.4L7.5 273c-10-10-10-26.2 0-36.2l36.2-36.2c10-10 26.2-10 36.2 0L192 312.7 432.1 72.6c10-10 26.2-10 36.2 0l36.2 36.2c10 10 10 26.2 0 36.2l-294.4 294.4c-10 10-26.2 10-36.2 0z" }));
+exports.checkIconMarkup = checkIconMarkup;
+/** `unselected`: the wrapper of the "not selected" state (2.x BooleanFieldValue used `Selected` there too, Field.tsx:167). */
+const mark = (selected, label, unselected = "NotSelected") => selected
+    ? (0, vnode_1.h)("div", { class: (0, exports.viewClass)("Selected") }, (0, vnode_1.h)("div", { class: (0, exports.viewClass)("SelectedBox") }, (0, exports.checkIconMarkup)()), (0, vnode_1.h)("span", { class: CHOICE.label }, label))
+    : (0, vnode_1.h)("div", { class: (0, exports.viewClass)(unselected) }, (0, vnode_1.h)("div", { class: (0, exports.viewClass)("NotSelectedBox") }), (0, vnode_1.h)("span", { class: CHOICE.label }, label));
+/** BooleanFieldValue's default markup. */
+const booleanValueMarkup = (selected, label) => (0, vnode_1.h)("div", { class: (0, exports.viewClass)("BooleanFieldValue") }, mark(selected, label, "Selected"));
+exports.booleanValueMarkup = booleanValueMarkup;
+/** MultipleChoiceFieldValue's default markup. */
+/** `style`: the ui:style layout keyword (2.x getStyle on the container). */
+const choicesValueMarkup = (options, style) => (0, vnode_1.h)("div", { class: (0, exports.viewClass)("MultipleChoiceFieldWrapper") }, (0, vnode_1.h)("div", { class: CHOICE.container, ...(0, choiceStyle_1.choiceStyle)(style) }, options.map((o) => (0, vnode_1.h)("label", { class: CHOICE.element, "data-fjsf-enum-value-view": o.value }, mark(o.selected, o.title)))));
+exports.choicesValueMarkup = choicesValueMarkup;

package/dist/cjs/v3/raw/model/view/toVNode.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toVNode = void 0;
+const uiSchema_1 = require("../../core/uiSchema");
+const vnode_1 = require("../vnode");
+const markup_1 = require("./markup");
+/** The 2.x template props: the field props plus the data attributes the field passes. */
+const templateProps = (node) => ({
+    ...Object.fromEntries(Object.entries(node.attrs)
+        .filter(([k]) => k === "data-fjsf-kind" || k === "data-fjsf-object" || k === "data-fjsf-level")
+        // 2.x ObjectField passed the level as a number.
+        .map(([k, v]) => [k, k === "data-fjsf-level" ? Number(v) : v])),
+    name: node.path,
+    schema: node.schema,
+    uiSchema: node.ui,
+});
+const templated = (template, node, markup, children, extra = {}) => {
+    const override = node.ui?.["ui:template"];
+    // A fragment carries the template mark, so the markup's root keeps its own (component) mark: a slot on
+    // FieldWrapper / ObjectFieldTemplateWrapper still applies when the template is the default.
+    return (0, vnode_1.withHost)((0, vnode_1.h)("#fragment", {}, markup), { kind: "template", template, ...(typeof override === "string" ? { override } : {}), props: templateProps(node), children, ...extra });
+};
+const fieldTemplate = (node, ...content) => templated("FieldTemplate", node, (0, markup_1.fieldTemplateMarkup)(node, content), content);
+const childVNode = (c) => (c.render === "section" ? (0, markup_1.sectionMarkup)(c.title, c.children.map(exports.toVNode)) : (0, exports.toVNode)(c));
+const toVNode = (node) => {
+    switch (node.render) {
+        case "object": {
+            const content = node.children.map(childVNode);
+            return templated("ObjectFieldTemplate", node, (0, markup_1.objectTemplateMarkup)(node, content), content, { childFields: node.childFields, chain: node.chain });
+        }
+        case "array": {
+            const items = node.items.map((item) => (0, markup_1.component)(["ArrayFieldItem"], {}, "node" in item ? (0, exports.toVNode)(item.node) : (0, vnode_1.h)("div", { "data-keyword": item.keyword }, item.text)));
+            return templated("ArrayFieldTemplate", node, (0, markup_1.arrayTemplateMarkup)(node, items), items, { items: node.values, itemNodes: items });
+        }
+        case "text":
+            return fieldTemplate(node, (0, markup_1.component)(["StringFieldValue"], { "data-keyword": node.keyword }, node.text));
+        case "textarea":
+            return fieldTemplate(node, (0, markup_1.component)(["TextAreaValue"], {}, node.text));
+        case "boolean": {
+            const props = { name: node.path, value: node.value, label: node.uiLabel, selectedLabel: node.selectedLabel, notSelectedLabel: node.notSelectedLabel };
+            return fieldTemplate(node, (0, markup_1.component)(["BooleanFieldWrapper"], {}, (0, markup_1.composite)("BooleanFieldValue", props, undefined, (0, markup_1.booleanValueMarkup)(node.selected, node.label))));
+        }
+        case "choices": {
+            const { props: inputProps, style } = (0, uiSchema_1.extractUiSchema)(node.ui);
+            const props = {
+                inputProps, name: node.path, style,
+                values: node.options.map((o) => ({ const: o.const, title: o.title, selected: o.selected })),
+            };
+            return fieldTemplate(node, (0, markup_1.composite)("MultipleChoiceFieldValue", props, undefined, (0, markup_1.choicesValueMarkup)(node.options, style)));
+        }
+        case "null":
+            return fieldTemplate(node);
+        case "slot": {
+            const markup = (0, markup_1.fieldTemplateMarkup)(node, [(0, vnode_1.h)("div", { "data-fjsf-slot": node.path, "data-fjsf-field": node.field })]);
+            return (0, vnode_1.withHost)(markup, { kind: "field", field: node.field, props: { "data-fjsf-kind": "custom", name: node.path, schema: node.schema, uiSchema: node.ui }, chain: node.chain });
+        }
+        case "any":
+            return (0, vnode_1.h)("div", node.attrs, (0, vnode_1.h)("select", {}, ["array", "boolean", "integer", "number", "object", "string", "null", "any"].map((t) => (0, vnode_1.h)("option", { value: t, selected: t === node.type }, t))), (0, exports.toVNode)(node.child));
+        case "unsupported":
+            return (0, vnode_1.h)("p", { style: "color:red" }, node.text);
+        case "plain":
+            return node.text;
+        case "none":
+            return null;
+    }
+};
+exports.toVNode = toVNode;

package/dist/cjs/v3/raw/model/view/values.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.descriptionOf = exports.titleOf = exports.textOf = exports.reactAttr = exports.reactText = void 0;
+const json_1 = require("../../core/json");
+const vnode_1 = require("../vnode");
+/**
+ * A React element (`$$typeof`) in a uiSchema text: kept for the React layer (2.x UiSchema allows ReactNode).
+ * In RAW DOM (S6) the host's own value is a DOM node, drawn by toDOM.
+ */
+const elementLike = (value) => typeof value === "object" && value !== null && ("$$typeof" in value || (typeof value.nodeType === "number" && typeof value.cloneNode === "function"));
+const hostValue = (value) => (0, vnode_1.withHost)((0, vnode_1.h)("#fragment", {}), { kind: "value", value });
+/** Text React renders for a child value. */
+const reactText = (value) => {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number")
+        return Number.isNaN(value) ? "NaN" : String(value);
+    if (Array.isArray(value))
+        return value.map(exports.reactText).join("");
+    return ""; // boolean, null, undefined: nothing; plain object: 2.x crashed
+};
+exports.reactText = reactText;
+/** Attribute value React writes for a data-* attribute, or undefined (omitted). */
+const reactAttr = (value) => {
+    if (value === undefined || value === null)
+        return undefined;
+    if ((0, json_1.isPlainObject)(value))
+        return undefined; // 2.x crashed on this value
+    if (Array.isArray(value))
+        return value.map((v) => (v === null || v === undefined ? "" : String(v))).join(",");
+    return String(value);
+};
+exports.reactAttr = reactAttr;
+/** 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. */
+const textOf = (value) => {
+    if (elementLike(value))
+        return hostValue(value);
+    return value ? (0, exports.reactText)(value) || undefined : undefined;
+};
+exports.textOf = textOf;
+const titleOf = (uiSchema, schema, name) => {
+    if (uiSchema?.["ui:options"]?.hideTitle)
+        return undefined;
+    const segments = name.split(".");
+    const title = uiSchema?.["ui:title"] || schema?.title || segments[segments.length - 1];
+    if (elementLike(title))
+        return hostValue(title);
+    return typeof title === "string" && title ? title : title ? (0, exports.reactText)(title) || undefined : undefined;
+};
+exports.titleOf = titleOf;
+const descriptionOf = (uiSchema, schema) => {
+    const d = uiSchema?.["ui:options"]?.description || uiSchema?.["ui:description"] || schema?.description;
+    if (elementLike(d))
+        return hostValue(d);
+    return d ? (0, exports.reactText)(d) || undefined : undefined;
+};
+exports.descriptionOf = descriptionOf;

package/dist/cjs/v3/raw/model/vnode.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cx = exports.hole = exports.withOn = exports.withHost = exports.h = void 0;
+const h = (tag, attrs = {}, ...children) => ({
+    tag,
+    attrs,
+    children: children.flat(),
+});
+exports.h = h;
+/** The same node, marked with the extension point that produced it (ignored by toString). */
+const withHost = (node, host) => ({ ...node, host });
+exports.withHost = withHost;
+/** The same node with event descriptors (merged over existing ones). */
+const withOn = (node, on) => ({ ...node, on: { ...node.on, ...on } });
+exports.withOn = withOn;
+/** Where a React template puts its children; serialises to nothing. */
+const hole = (name) => ({ tag: "#hole", attrs: {}, children: [], host: { kind: "hole", ...(name ? { name } : {}) } });
+exports.hole = hole;
+/** Joins class names, skipping empty parts. */
+const cx = (...names) => names.filter(Boolean).join(" ") || undefined;
+exports.cx = cx;

package/dist/cjs/v3/raw/sanitize/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSanitizerWindow = exports.sanitizeHtml = exports.STRICT_CONFIG = exports.SanitizerUnavailableError = exports.SANITIZER_UNAVAILABLE = void 0;
+// The TASK-055 sanitiser (framework-free, dompurify only), at home in the RAW layer since the 3.0.0 cut-over.
+var sanitizeHtml_1 = require("./sanitizeHtml");
+Object.defineProperty(exports, "SANITIZER_UNAVAILABLE", { enumerable: true, get: function () { return sanitizeHtml_1.SANITIZER_UNAVAILABLE; } });
+Object.defineProperty(exports, "SanitizerUnavailableError", { enumerable: true, get: function () { return sanitizeHtml_1.SanitizerUnavailableError; } });
+Object.defineProperty(exports, "STRICT_CONFIG", { enumerable: true, get: function () { return sanitizeHtml_1.STRICT_CONFIG; } });
+Object.defineProperty(exports, "sanitizeHtml", { enumerable: true, get: function () { return sanitizeHtml_1.sanitizeHtml; } });
+Object.defineProperty(exports, "setSanitizerWindow", { enumerable: true, get: function () { return sanitizeHtml_1.setSanitizerWindow; } });

package/dist/cjs/v3/raw/sanitize/sanitizeHtml.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeHtml = exports.setSanitizerWindow = exports.STRICT_CONFIG = exports.SanitizerUnavailableError = exports.SANITIZER_UNAVAILABLE = void 0;
+const dompurify_1 = __importDefault(require("dompurify"));
+/** Code of the error thrown when there is no DOM to sanitise with. */
+exports.SANITIZER_UNAVAILABLE = "SANITIZER_UNAVAILABLE";
+class SanitizerUnavailableError extends Error {
+    code = exports.SANITIZER_UNAVAILABLE;
+    constructor() {
+        super(`${exports.SANITIZER_UNAVAILABLE}: sanitizeHtml needs a DOM window. In Node, pass ` +
+            "one (e.g. from jsdom) as `options.window` or register it with " +
+            "`setSanitizerWindow`. Unsanitised HTML is never returned.");
+        this.name = "SanitizerUnavailableError";
+    }
+}
+exports.SanitizerUnavailableError = SanitizerUnavailableError;
+// D5 (approved): formatting, links and images only. Everything that can
+// submit data, load code or styles, or restyle the page is forbidden, and
+// only absolute http(s) URLs survive.
+const STRICT = {
+    FORBID_TAGS: [
+        "form",
+        "input",
+        "button",
+        "select",
+        "textarea",
+        "label",
+        "style",
+        "svg",
+        "math",
+        "iframe",
+        "object",
+        "embed",
+        "link",
+        "meta",
+        "base",
+        // D5 (formatting, links, images): remote media is not formatting.
+        "video",
+        "audio",
+        "source",
+        "track",
+        // DOMPurify keeps a <template> nested in a forbidden parent (select, form,
+        // label...): inert and sanitised, but not idempotent.
+        "template",
+    ],
+    FORBID_ATTR: [
+        "style",
+        "id",
+        "name",
+        "action",
+        "formaction",
+        "srcset",
+        "xlink:href",
+    ],
+    ALLOWED_URI_REGEXP: /^https?:/i,
+    SANITIZE_NAMED_PROPS: true,
+    // Data must not forge the data-fjsf-* / data-keyword markers that pro3's
+    // persisted CSS and tests key off.
+    ALLOW_DATA_ATTR: false,
+    // The URI regex is applied to every attribute DOMPurify does not treat as
+    // URI-safe, which would strip these harmless table/text attributes (base
+    // decision). width/height/start/border stay stripped.
+    ADD_URI_SAFE_ATTR: ["colspan", "rowspan", "lang", "dir"],
+};
+exports.STRICT_CONFIG = Object.freeze({
+    ...STRICT,
+    FORBID_TAGS: Object.freeze([...STRICT.FORBID_TAGS]),
+    FORBID_ATTR: Object.freeze([...STRICT.FORBID_ATTR]),
+    ADD_URI_SAFE_ATTR: Object.freeze([...STRICT.ADD_URI_SAFE_ATTR]),
+});
+const instances = new WeakMap();
+let registeredWindow;
+/**
+ * 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).
+ */
+const setSanitizerWindow = (window) => {
+    registeredWindow = window;
+};
+exports.setSanitizerWindow = setSanitizerWindow;
+const URL_ATTRIBUTES = ["href", "src", "xlink:href", "action", "formaction"];
+const createInstance = (window) => {
+    const purify = (0, dompurify_1.default)(window);
+    if (!purify.isSupported)
+        throw new SanitizerUnavailableError();
+    purify.addHook("afterSanitizeAttributes", (node) => {
+        // ALLOWED_URI_REGEXP is bypassed by DOMPurify for data: images; the
+        // approved policy is http(s) only.
+        URL_ATTRIBUTES.forEach((attr) => {
+            if (/^\s*data:/i.test(node.getAttribute?.(attr) ?? "")) {
+                node.removeAttribute(attr);
+            }
+        });
+        if (node.nodeName === "A" && node.hasAttribute("href")) {
+            node.setAttribute("rel", "noopener noreferrer");
+        }
+    });
+    return purify;
+};
+const resolveWindow = (options) => options?.window ??
+    registeredWindow ??
+    // the browser's window, read through globalThis (the RAW layer reads no DOM global directly, §1.6)
+    globalThis.window;
+/**
+ * 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.
+ */
+const sanitizeHtml = (html, options) => {
+    const win = resolveWindow(options);
+    if (!win)
+        throw new SanitizerUnavailableError();
+    let purify = instances.get(win);
+    if (!purify) {
+        purify = createInstance(win);
+        instances.set(win, purify);
+    }
+    return purify.sanitize(String(html), exports.STRICT_CONFIG);
+};
+exports.sanitizeHtml = sanitizeHtml;

package/dist/cjs/v3/raw/serialize/toDOM.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDOM = exports.patchChildren = void 0;
+const SAFE_NAME = /^[a-zA-Z_:][-a-zA-Z0-9_:.]*$/;
+const SAFE_TAG = /^[a-z][a-z0-9-]*$/;
+const HANDLER = /^on/i;
+const BOOLEAN = new Set(["selected", "checked", "disabled", "readonly", "multiple", "hidden", "required"]);
+const SVG_NS = "http://www.w3.org/2000/svg";
+/** Fragments, holes and host replacements flattened into the list of children to draw. */
+const flatten = (children, env, out = []) => {
+    for (const child of children) {
+        if (child === null || child === undefined || child === false)
+            continue;
+        if (typeof child === "string" || typeof child === "number")
+            out.push(String(child));
+        else {
+            const replaced = child.host ? env.host?.(child) : undefined;
+            if (replaced)
+                flatten(replaced, env, out);
+            else if (child.tag === "#fragment")
+                flatten(child.children, env, out);
+            else if (child.tag === "#hole")
+                continue;
+            else if (SAFE_TAG.test(child.tag))
+                out.push(child);
+        }
+    }
+    return out;
+};
+const attributesOf = (node) => {
+    const out = new Map();
+    for (const [name, value] of Object.entries(node.attrs)) {
+        if (!SAFE_NAME.test(name) || HANDLER.test(name) || value === undefined || value === null || value === false)
+            continue;
+        // a textarea's / select's value is state, not an attribute (as React draws them)
+        if (Array.isArray(value) || (name === "value" && (node.tag === "textarea" || node.tag === "select")))
+            continue;
+        out.set(name, value === true ? (BOOLEAN.has(name) ? "" : "true") : String(value));
+    }
+    return out;
+};
+const isControl = (el) => el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT";
+/** Live state of form controls: set as properties, and only when it differs (no caret jumps). */
+const syncControl = (el, node) => {
+    const { value, checked } = node.attrs;
+    if (el.tagName === "INPUT" && (el.type === "checkbox" || el.type === "radio")) {
+        const want = checked === true;
+        if (el.checked !== want)
+            el.checked = want;
+    }
+    else if (el.tagName === "SELECT" && el.multiple) {
+        const want = new Set(Array.isArray(value) ? value.map(String) : []);
+        for (const option of el.options)
+            if (option.selected !== want.has(option.value))
+                option.selected = want.has(option.value);
+    }
+    else if (el.tagName === "SELECT" && value === undefined) {
+        // the option marked `selected` is the selection (React: the select's value), whatever the insertion order did
+        const marked = [...el.options].find((o) => o.hasAttribute("selected"));
+        if (marked)
+            for (const o of el.options)
+                if (o.selected !== (o === marked))
+                    o.selected = o === marked;
+    }
+    else if (el.tagName === "TEXTAREA") {
+        // React keeps a textarea's text (defaultValue) equal to its value
+        const want = value === undefined || value === null ? "" : String(value);
+        if (el.defaultValue !== want)
+            el.defaultValue = want;
+        if (el.value !== want)
+            el.value = want;
+    }
+    else if (el.type !== "file" && value !== undefined) {
+        const want = value === null ? "" : String(value);
+        if (el.value !== want)
+            el.value = want;
+    }
+};
+const create = (node, env, svg) => svg || node.tag === "svg" ? env.doc.createElementNS(SVG_NS, node.tag) : env.doc.createElement(node.tag);
+/** The style text each element was last given (the attribute holds the browser's serialisation). */
+const styles = new WeakMap();
+/** A style goes through the CSSOM, so the attribute reads as React writes it ("display: none;"). */
+const setStyle = (el, value) => {
+    if (styles.get(el) === value)
+        return;
+    styles.set(el, value);
+    const style = el.style;
+    if (style)
+        style.cssText = value;
+    else
+        el.setAttribute("style", value);
+};
+const patchElement = (el, node, env) => {
+    const want = attributesOf(node);
+    for (const attr of [...el.attributes])
+        if (!want.has(attr.name))
+            el.removeAttribute(attr.name);
+    if (!want.has("style"))
+        styles.delete(el);
+    for (const [name, value] of want) {
+        if (name === "style")
+            setStyle(el, value);
+        else if (el.getAttribute(name) !== value)
+            el.setAttribute(name, value);
+    }
+    if (node.on)
+        env.on.set(el, node.on);
+    else
+        env.on.delete(el);
+    const svg = el.namespaceURI === SVG_NS;
+    // A slot (§2.6) is filled by the host: its content is not ours to patch.
+    if (el.tagName !== "INPUT" && el.tagName !== "TEXTAREA" && node.attrs["data-fjsf-slot"] === undefined)
+        (0, exports.patchChildren)(el, node.children, env, svg);
+    if (isControl(el))
+        syncControl(el, node);
+    env.drawn?.(el, node);
+};
+/** Makes `parent`'s children match `children` (in place where tags match). */
+const patchChildren = (parent, children, env, svg = false) => {
+    const flat = flatten(children, env);
+    flat.forEach((child, i) => {
+        const existing = parent.childNodes[i];
+        if (typeof child === "string") {
+            if (existing && existing.nodeType === 3) {
+                if (existing.data !== child)
+                    existing.data = child;
+            }
+            else
+                insert(parent, env.doc.createTextNode(child), existing);
+            return;
+        }
+        const same = existing && existing.nodeType === 1 && existing.localName === child.tag;
+        const el = same ? existing : create(child, env, svg);
+        if (!same)
+            insert(parent, el, existing);
+        patchElement(el, child, env);
+    });
+    while (parent.childNodes.length > flat.length)
+        parent.removeChild(parent.lastChild);
+};
+exports.patchChildren = patchChildren;
+const insert = (parent, node, existing) => {
+    if (existing)
+        parent.replaceChild(node, existing);
+    else
+        parent.appendChild(node);
+};
+/** Draws `node` as the only content of `target`. */
+const toDOM = (target, node, env) => (0, exports.patchChildren)(target, [node], env);
+exports.toDOM = toDOM;