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

package/dist/cjs/v3/react/view/templates.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormViewTemplates = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const markup_1 = require("../../raw/model/view/markup");
+const fields_1 = require("../../raw/model/view/fields");
+const values_1 = require("../../raw/model/view/values");
+const vnode_1 = require("../../raw/model/vnode");
+const host_1 = require("./host");
+/** 2.x getInstrumentationAttributes. */
+const instrumentation = (props) => ({
+    "data-fjsf-path": props.name ?? "",
+    "data-fjsf-kind": props["data-fjsf-kind"],
+    "data-fjsf-required": props.required ? "true" : undefined,
+    "data-fjsf-readonly": props.schema?.readOnly ? "true" : undefined,
+    "data-fjsf-hidden": props["data-fjsf-hidden"],
+});
+/** 2.x getTitle/getDescription: an explicit `title`/`description` prop wins. */
+const chrome = (props, attrs) => {
+    const ui = props.uiSchema ?? {};
+    const name = props.name ?? "";
+    const { wrapperAttrs, titleAttrs, descriptionAttrs } = (0, fields_1.elementProps)(ui, name);
+    return {
+        path: name,
+        attrs: { ...wrapperAttrs, ...attrs },
+        titleAttrs,
+        descriptionAttrs,
+        title: (0, values_1.titleOf)(props.title ? { ...ui, "ui:title": props.title } : ui, props.schema, name),
+        description: (0, values_1.descriptionOf)(props.description ? { ...ui, "ui:options": { ...ui["ui:options"], description: props.description } } : ui, props.schema),
+    };
+};
+const FieldTemplate = (props) => {
+    const render = (0, host_1.useViewRender)();
+    return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: render((0, markup_1.fieldTemplateMarkup)(chrome(props, instrumentation(props)), [(0, vnode_1.hole)()]), props.children) });
+};
+const ObjectFieldTemplate = (props) => {
+    const render = (0, host_1.useViewRender)();
+    const data = Object.fromEntries(Object.entries(props).filter(([key]) => key.startsWith("data-")));
+    return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: render((0, markup_1.objectTemplateMarkup)(chrome(props, { ...data, ...instrumentation(props) }), [(0, vnode_1.hole)()]), props.children) });
+};
+const ArrayFieldTemplate = (props) => {
+    const render = (0, host_1.useViewRender)();
+    const items = Array.isArray(props.items) ? props.items.map((item, index) => props.renderItem(item, index)) : null;
+    return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: render((0, markup_1.arrayTemplateMarkup)(chrome(props, instrumentation(props)), [(0, vnode_1.hole)()]), items) });
+};
+exports.FormViewTemplates = {
+    ArrayFieldTemplate,
+    FieldTemplate,
+    ObjectFieldTemplate,
+};

package/dist/esm/common/types/index.js

@@ -1,4 +1,6 @@
+// The public types (dist/types/common/types, a path pro3 deep-imports until 4.0).
 export * from "./Field";
 export * from "./Form";
 export * from "./Schemas";
 export * from "./Templates";
+export * from "./Utils";

package/dist/esm/index.js

@@ -1,5 +1,8 @@
-//This file exists for purpose releasing "moduleResolution": "node" compatible version (until we split this to multiple packages)
-export * from "./common";
-export * from "./Form";
-export * from "./FormView";
-export * from "./utils";
+// The package root from 3.0.0 (§1.5): the v3 React layer, with every name the 2.x root exported (C1):
+// the 2.x-signature utilities, the sanitiser, the 2.x type names, and the deprecated compat map
+// (FormComponents / FormViewComponents, `registry.components`, `styled(FormComponents.X)`; CM-a, until 4.0).
+export * from "./v3/react";
+export * from "./v3/raw/compat/v2utils";
+export { SANITIZER_UNAVAILABLE, SanitizerUnavailableError, sanitizeHtml, setSanitizerWindow } from "./v3/raw/sanitize";
+export * from "./common/types";
+export { COMPONENT_TYPES, FormWrapper } from "./v3/react/compat";

package/dist/esm/v3/document/fromDocument.js

@@ -0,0 +1,46 @@
+import { ignoreIssues, issue } from "../raw/core/issues";
+import { isPlainObject } from "../raw/core/json";
+const FILE_UPLOAD_VIEWS = ["todo", "hide"];
+const EMPTY_SCHEMA = () => ({ type: "object", properties: {} });
+export const fromDocument = (input, sink = ignoreIssues) => {
+    const invalid = (path) => sink(issue("DOCUMENT_INVALID", path || undefined));
+    const doc = isPlainObject(input) ? input : undefined;
+    if (!doc) {
+        invalid("");
+        return { schema: EMPTY_SCHEMA(), uiSchema: {}, values: undefined, options: {} };
+    }
+    let schema = doc.schema;
+    if (!isPlainObject(schema)) {
+        invalid("schema");
+        schema = EMPTY_SCHEMA();
+    }
+    let uiSchema = doc.uiSchema;
+    if (uiSchema === undefined)
+        uiSchema = {};
+    else if (!isPlainObject(uiSchema)) {
+        invalid("uiSchema");
+        uiSchema = {};
+    }
+    const options = {};
+    if (doc.formLocalization !== undefined) {
+        if (isPlainObject(doc.formLocalization))
+            options.formLocalization = doc.formLocalization;
+        else
+            invalid("formLocalization");
+    }
+    if (doc.customFields !== undefined) {
+        if (Array.isArray(doc.customFields) && doc.customFields.every((n) => typeof n === "string"))
+            options.customFields = doc.customFields;
+        else
+            invalid("customFields");
+    }
+    if (doc.fileUploadView !== undefined) {
+        if (typeof doc.fileUploadView === "string" && FILE_UPLOAD_VIEWS.includes(doc.fileUploadView))
+            options.fileUploadView = doc.fileUploadView;
+        else
+            invalid("fileUploadView");
+    }
+    if (sink !== ignoreIssues)
+        options.sink = sink;
+    return { schema, uiSchema, values: doc.data, options };
+};

package/dist/esm/v3/document/index.js

@@ -0,0 +1,4 @@
+// @nolwenture/formik-jsonschema-form/document (v3, slice S8): documents -> the read-only view as an HTML string.
+// No React, no DOM, no ejs (the EJS field is the opt-in `./react/ejs`). Layer boundary: src/v3/document/** like RAW.
+export { fromDocument } from "./fromDocument";
+export { renderDocumentToString } from "./render";

package/dist/esm/v3/document/render.js

@@ -0,0 +1,18 @@
+import { ignoreIssues, issue } from "../raw/core/issues";
+import { renderViewToString } from "../raw/model/view";
+import { fromDocument } from "./fromDocument";
+/** CSS text that cannot close the <style> element it is put in. */
+const safeCss = (css) => css.replace(/<\/(style)/gi, "<\\/$1");
+export const renderDocumentToString = (input, options = {}) => {
+    const sink = options.sink ?? ignoreIssues;
+    const { schema, uiSchema, values, options: view } = fromDocument(input, sink);
+    const html = renderViewToString(schema, uiSchema, values, view);
+    let css = "";
+    try {
+        css = typeof options.styles === "function" ? options.styles() : options.styles ?? "";
+    }
+    catch {
+        sink(issue("DOCUMENT_INVALID", "styles"));
+    }
+    return typeof css === "string" && css ? `<style>${safeCss(css)}</style>${html}` : html;
+};

package/dist/esm/v3/raw/compat/v2utils.js

@@ -0,0 +1,15 @@
+// Interim seam (until TASK-061): exposes the v3 RAW core under the 2.x util names so
+// the §7b S1 suites run unchanged against v3 (jest.v3.config.js maps their relative
+// imports here). Test-only; not exported from the package.
+import { getSchemaType, guessType, defaultValueForType } from "../core/schemaType";
+export const isObject = (object) => object != null && typeof object === "object";
+export const getDefaultValueForType = defaultValueForType;
+export { getSchemaType, guessType };
+export { createInitialValues } from "../core/initialValues";
+export { createValidationSchema } from "../validation";
+export { hasReferences, solveReferences } from "../core/refs";
+export { mergeSchemas } from "../core/merge";
+export { deepOverlap, resolveOneOfValue, resolveSchema } from "../core/conditionals";
+export { extractUiSchema, getDescription, getHiddenProperties, getTitle, orderAdditionalProperties, orderByUiSchema } from "../core/uiSchema";
+export { EnumsTypes, getEnums, getSelectedEnum } from "../core/enums";
+export { immutablySwapItems, setTitleValues } from "../core/titles";

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

@@ -0,0 +1,49 @@
+import { isPlainObject, jsonTypeOf } from "./json";
+import { ignoreIssues, issue } from "./issues";
+import { normaliseType } from "./schemaType";
+const asSchema = (value) => {
+    if (value === true)
+        return {};
+    return isPlainObject(value) ? value : undefined;
+};
+export const normalizeArraySchema = (schema, sink = ignoreIssues, path) => {
+    const items = schema?.items;
+    const additional = asSchema(schema?.additionalItems);
+    if (Array.isArray(items)) {
+        return { fixed: items.map(asSchema).filter((s) => s !== undefined), tail: additional };
+    }
+    const single = asSchema(items);
+    if (single && additional) {
+        // N-1: a single `items` next to an `additionalItems` schema is a placeholder.
+        const extraKeys = Object.keys(single).filter((k) => k !== "type");
+        if (extraKeys.length > 0)
+            sink(issue("SCHEMA_ARRAY_AMBIGUOUS", path, "items ignored next to additionalItems"));
+        return { fixed: [], tail: additional, placeholder: single };
+    }
+    if (single)
+        return { fixed: [], tail: single }; // D2 Q-VAL-5: `items` object applies to every item
+    return { fixed: [], tail: additional };
+};
+/** True when a stored value's JSON type cannot be an instance of the schema's type. */
+export const valueTypeMismatch = (value, schema) => {
+    if (value === undefined || !schema)
+        return false;
+    const { type, nullable } = normaliseType(schema);
+    const actual = jsonTypeOf(value);
+    if (type === "any")
+        return false;
+    if (actual === "null")
+        return !(nullable || type === "null");
+    if (type === "integer")
+        return actual !== "number";
+    return actual !== type;
+};
+/** Schema used for item `index`, given the stored value of that item. */
+export const itemSchema = (norm, index, value) => {
+    if (index < norm.fixed.length)
+        return { schema: norm.fixed[index], guarded: false, fixed: true };
+    if (index === 0 && norm.placeholder && valueTypeMismatch(value, norm.tail)) {
+        return { schema: norm.placeholder, guarded: true, fixed: false };
+    }
+    return { schema: norm.tail, guarded: false, fixed: false };
+};

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

@@ -0,0 +1,10 @@
+// 2.x getStyle (src/utils/getStyle.ts): the MultipleChoice container layout of `ui:style` /
+// `ui:options.style`, used by the Form and the FormView alike.
+const STYLES = {
+    inline: "flex-direction:row",
+    oneColumn: "display:grid",
+    twoColumns: "display:grid;grid-template-columns:1fr 1fr",
+    threeColumns: "display:grid;grid-template-columns:1fr 1fr 1fr",
+};
+/** The container's style attribute for a layout keyword, or nothing. */
+export const choiceStyle = (style) => typeof style === "string" && Object.prototype.hasOwnProperty.call(STYLES, style) ? { style: STYLES[style] } : {};

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

@@ -0,0 +1,82 @@
+import { isPlainObject, isSchemaObject, safeKeys } from "./json";
+import { mergeSchemas } from "./merge";
+/** 2.x deepOverlap: every key of `a` is present in `b` with an equal (or overlapping) value. */
+export const deepOverlap = (a, b) => {
+    if (a === null || typeof a !== "object")
+        return a === b;
+    for (const key of Object.keys(a)) {
+        const left = a[key];
+        const right = b !== null && typeof b === "object" ? b[key] : undefined;
+        const bothObjects = left !== null && typeof left === "object" && right !== null && typeof right === "object";
+        if ((bothObjects && !deepOverlap(left, right)) || (!bothObjects && left !== right))
+            return false;
+    }
+    return true;
+};
+export function resolveOneOfValue(value) {
+    if (value === true || value === false)
+        return value;
+    if (isSchemaObject(value) && value.enum?.[0] !== undefined)
+        return value.enum[0];
+    return undefined;
+}
+const resolveEquality = (value, expression) => {
+    const properties = {};
+    for (const key of safeKeys(value))
+        properties[key] = { const: value[key] };
+    return deepOverlap(expression, { properties });
+};
+const selectedOneOf = (key, value, oneOf) => {
+    const match = (oneOf.find((one) => isPlainObject(one) && isPlainObject(one.properties)
+        ? resolveOneOfValue(one.properties[key]) === value[key]
+        : false) ?? {});
+    const properties = {};
+    for (const inner of safeKeys(match.properties)) {
+        if (inner !== key)
+            properties[inner] = match.properties[inner];
+    }
+    return { ...match, properties };
+};
+/** Same contract as 2.x resolveSchema: `[resolvedSchema, keysToPrune]`. */
+export const resolveSchema = (input, rawValue) => {
+    const value = isPlainObject(rawValue) ? rawValue : {};
+    const { allOf, dependencies, ...schema } = isPlainObject(input) ? input : {};
+    let resolved = schema;
+    const pruneDeps = [];
+    if (isPlainObject(dependencies)) {
+        for (const [key, dependency] of Object.entries(dependencies)) {
+            if (value[key] === undefined || value[key] === "" || !isPlainObject(dependency))
+                continue;
+            const oneOf = dependency.oneOf;
+            resolved = mergeSchemas(resolved, Array.isArray(oneOf) ? selectedOneOf(key, value, oneOf) : dependency);
+        }
+        const used = Object.keys(resolved.properties ?? {});
+        for (const key of safeKeys(value))
+            if (!used.includes(key))
+                pruneDeps.push(key);
+        if (!allOf)
+            return [resolved, pruneDeps];
+    }
+    if (!Array.isArray(allOf))
+        return [resolved, []];
+    let notAdded = [];
+    for (const current of allOf) {
+        if (!isPlainObject(current))
+            continue;
+        const { if: expression, then, else: otherwise, ...rest } = current;
+        if (!isPlainObject(expression)) {
+            resolved = mergeSchemas(resolved, rest);
+            continue;
+        }
+        const matches = resolveEquality(value, expression);
+        const taken = matches ? then : otherwise;
+        const skipped = matches ? otherwise : then;
+        if (isPlainObject(taken))
+            resolved = mergeSchemas(resolved, taken);
+        if (isPlainObject(skipped))
+            notAdded = [...notAdded, ...Object.keys(skipped.properties ?? {})];
+    }
+    const used = Object.keys(resolved.properties ?? {});
+    const pruneAllOf = [...new Set(notAdded)].filter((key) => !used.includes(key) && value[key] !== undefined);
+    return [resolved, [...new Set([...pruneDeps, ...pruneAllOf])]];
+};

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

@@ -0,0 +1,66 @@
+export const toIsoDateString = (date) => date.toISOString().slice(0, 10);
+export const isValidYMD = (y, m, d) => {
+    if (!y || !m || !d)
+        return false;
+    const dt = new Date(Date.UTC(y, m - 1, d));
+    return dt.getUTCFullYear() === y && dt.getUTCMonth() === m - 1 && dt.getUTCDate() === d;
+};
+const ymd = (y, m, d) => (isValidYMD(y, m, d) ? new Date(Date.UTC(y, m - 1, d)) : undefined);
+export const parseDateString = (input, preferOrder) => {
+    const s = input.trim();
+    if (!s)
+        return undefined;
+    let m = s.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/) || s.match(/^(\d{4})\/(\d{1,2})\/(\d{1,2})$/);
+    if (m)
+        return ymd(+m[1], +m[2], +m[3]);
+    m = s.match(/^(\d{1,2})\.(\d{1,2})\.(\d{4})$/);
+    if (m)
+        return ymd(+m[3], +m[2], +m[1]);
+    m = s.match(/^(\d{1,2})\.(\d{1,2})\.(\d{2})$/);
+    if (m)
+        return ymd(2000 + +m[3], +m[2], +m[1]);
+    m = s.match(/^(\d{1,2})\/(\d{1,2})\/(\d{2,4})$/);
+    if (m) {
+        const [a, b] = [+m[1], +m[2]];
+        const y = +m[3] < 100 ? 2000 + +m[3] : +m[3];
+        const dmy = ymd(y, b, a);
+        const mdy = ymd(y, a, b);
+        if (dmy && !mdy)
+            return dmy;
+        if (!dmy && mdy)
+            return mdy;
+        if (dmy && mdy)
+            return preferOrder === "MDY" ? mdy : dmy;
+    }
+    for (const r of [/^(\d{1,2})-(\d{1,2})-(\d{4})$/, /^(\d{1,2}) (\d{1,2}) (\d{4})$/]) {
+        const mm = s.match(r);
+        if (mm && isValidYMD(+mm[3], +mm[2], +mm[1]))
+            return ymd(+mm[3], +mm[2], +mm[1]);
+    }
+    return undefined;
+};
+/** The day/month order of the locale's date format. */
+export const preferOrderOf = (locale) => {
+    try {
+        const first = new Intl.DateTimeFormat(locale).formatToParts(new Date(Date.UTC(2000, 0, 2))).find((p) => p.type === "day" || p.type === "month" || p.type === "year");
+        return first?.type === "month" ? "MDY" : "DMY";
+    }
+    catch {
+        return "DMY";
+    }
+};
+/** What the display input shows for a stored value (2.x formatForDisplay; `"now"` shows today). */
+export const formatForDisplay = (iso, locale, now = new Date()) => {
+    if (typeof iso !== "string" || !iso)
+        return "";
+    try {
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(iso)) {
+            return iso === "now" ? new Intl.DateTimeFormat(locale, { timeZone: "UTC" }).format(new Date(Date.UTC(now.getFullYear(), now.getMonth(), now.getDate()))) : "";
+        }
+        const dt = new Date(`${iso}T00:00:00Z`);
+        return Number.isNaN(dt.getTime()) ? "" : new Intl.DateTimeFormat(locale, { timeZone: "UTC" }).format(dt);
+    }
+    catch {
+        return ""; // an invalid locale tag (BUG-109: never throw)
+    }
+};

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

@@ -0,0 +1,25 @@
+import { isSchemaObject } from "./json";
+import { defaultValueForType } from "./schemaType";
+/** Today's date as YYYY-MM-DD in local time (Q-DATE-1: 2.x used the UTC date). */
+export const localIsoDate = (now = new Date()) => {
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+};
+/** A value the user has not given yet: v3 applies defaults to these only. */
+export const isUnset = (value) => value === undefined || value === "";
+/**
+ * The value a field should get on appearance, or `undefined` for "leave it".
+ * Never overwrites a set value, honours `0`/`false` defaults.
+ */
+export const defaultFor = (schema, current, options = {}) => {
+    if (!isSchemaObject(schema) || !isUnset(current))
+        return undefined;
+    if (schema.default !== undefined) {
+        if (schema.format === "date" && schema.default === "now")
+            return localIsoDate(options.now);
+        return schema.default;
+    }
+    if (options.forceDefaultValue)
+        return defaultValueForType(schema.type);
+    return undefined;
+};

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

@@ -0,0 +1,32 @@
+import { ignoreIssues, issue } from "./issues";
+export var EnumsTypes;
+(function (EnumsTypes) {
+    EnumsTypes["SELECT"] = "select";
+    EnumsTypes["MULTI_SELECT"] = "multiSelect";
+})(EnumsTypes || (EnumsTypes = {}));
+export const getEnums = ({ schema }, sink = ignoreIssues, path) => {
+    if (!schema)
+        return { values: [] };
+    const defined = [schema.enum, schema.oneOf, schema.anyOf].filter((x) => x).length;
+    if (defined === 0)
+        return undefined;
+    if (defined > 1)
+        sink(issue("SCHEMA_ENUM_CONFLICT", path));
+    if (Array.isArray(schema.enum)) {
+        return { type: EnumsTypes.SELECT, values: schema.enum.map((option) => ({ const: option, title: `${option}` })) };
+    }
+    if (Array.isArray(schema.oneOf))
+        return { type: EnumsTypes.SELECT, values: schema.oneOf };
+    return { type: EnumsTypes.MULTI_SELECT, values: (Array.isArray(schema.anyOf) ? schema.anyOf : []) };
+};
+export const getSelectedEnum = (selected, enums) => {
+    if (Array.isArray(selected)) {
+        const found = selected
+            .map((v) => enums?.values.find((e) => e.const === v))
+            .filter((e) => !!e);
+        return found.length > 0 ? found : undefined;
+    }
+    if (typeof selected === "string" || typeof selected === "number")
+        return enums?.values.filter((e) => e.const === selected);
+    return undefined;
+};

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

@@ -0,0 +1,65 @@
+import { isPlainObject, PROTOTYPE_KEYS } from "./json";
+import { ignoreIssues, issue } from "./issues";
+import { optionalNumberInitialValue } from "./policies/optionalNumberInitial";
+import { resolveRefs } from "./refs";
+import { normaliseType } from "./schemaType";
+import { mayEnter } from "./trail";
+const OMIT = Symbol("omit");
+export function createInitialValues(schema, definitions = {}, options = {}) {
+    const sink = options.sink ?? ignoreIssues;
+    if (!isPlainObject(schema) || !isPlainObject(schema.properties))
+        return {};
+    const defs = { ...definitions, ...(isPlainObject(schema.definitions) ? schema.definitions : {}) };
+    const $defs = isPlainObject(schema.$defs) ? schema.$defs : undefined;
+    const valueOf = (node, required, path, chain, trail) => {
+        const ref = isPlainObject(node) && typeof node.$ref === "string" ? node.$ref : undefined;
+        if (ref && chain.includes(ref)) {
+            sink(issue("REF_CYCLE", path, ref));
+            return OMIT;
+        }
+        const nextChain = ref ? [...chain, ref] : chain;
+        const { schema: solved } = resolveRefs(node, {}, { definitions: defs, defs: $defs, sink, path });
+        if (isPlainObject(solved.properties))
+            return mayEnter(solved, trail, sink, path) ? objectOf(solved, path, nextChain, trail) : OMIT;
+        const { type } = normaliseType(solved);
+        switch (type) {
+            case "object":
+                return {};
+            case "array":
+                return [];
+            case "number":
+            case "integer": {
+                if (required)
+                    return 0;
+                const initial = optionalNumberInitialValue(options.optionalNumberInitial);
+                return initial === undefined ? OMIT : initial;
+            }
+            case "boolean":
+            case "null":
+            case "string":
+                return "";
+            default:
+                return OMIT;
+        }
+    };
+    const objectOf = (node, path, chain, above) => {
+        const trail = [...above, node];
+        const required = Array.isArray(node.required) ? node.required : [];
+        const result = {};
+        for (const key of Object.keys(node.properties ?? {})) {
+            const childPath = path ? `${path}.${key}` : key;
+            if (PROTOTYPE_KEYS.has(key)) {
+                sink(issue("KEY_REJECTED", childPath));
+                continue;
+            }
+            const child = node.properties[key];
+            if (!isPlainObject(child))
+                continue;
+            const value = valueOf(child, required.includes(key), childPath, chain, trail);
+            if (value !== OMIT)
+                result[key] = value;
+        }
+        return result;
+    };
+    return objectOf(schema, "", [], []);
+}

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

@@ -0,0 +1,36 @@
+// Error codes of the v3 RAW contract (§2.3). The RAW core reports problems as
+// codes and never stops: callers get a usable result plus a list of issues.
+export const ISSUE_CODES = [
+    "SCHEMA_UNSUPPORTED_TYPE",
+    "SCHEMA_MISSING_TYPE",
+    "SCHEMA_ARRAY_AMBIGUOUS",
+    "SCHEMA_ENUM_CONFLICT",
+    "REF_UNSUPPORTED",
+    "REF_NOT_FOUND",
+    "REF_CYCLE",
+    "REF_DEPTH_EXCEEDED",
+    "PATTERN_INVALID",
+    "PATTERN_REJECTED",
+    "PROP_REJECTED",
+    "KEY_REJECTED",
+    "KEY_AMBIGUOUS",
+    "FIELD_UNKNOWN",
+    "TEMPLATE_UNKNOWN",
+    "TEMPLATE_DISABLED",
+    "DOCUMENT_INVALID",
+    "SANITIZER_UNAVAILABLE",
+];
+/** Default sink: drops issues. Pure functions take an optional sink. */
+export const ignoreIssues = () => undefined;
+const WARNINGS = new Set(["SCHEMA_ARRAY_AMBIGUOUS", "SCHEMA_ENUM_CONFLICT", "KEY_AMBIGUOUS", "FIELD_UNKNOWN"]);
+export const issue = (code, path, detail) => ({
+    code,
+    severity: WARNINGS.has(code) ? "warning" : "error",
+    ...(path === undefined ? {} : { path }),
+    ...(detail === undefined ? {} : { detail }),
+});
+/** Collects issues into an array (tests and the controller use this). */
+export const collectIssues = () => {
+    const issues = [];
+    return { sink: (i) => issues.push(i), issues };
+};

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

@@ -0,0 +1,49 @@
+/** Keys that must never be read or written as data/schema keys (SEC-8, SEC-10). */
+export const PROTOTYPE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+export const hasOwn = (value, key) => value !== null && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key);
+export const isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+export const isSchemaObject = (value) => isPlainObject(value);
+/** JSON type name of a runtime value ("integer" is reported as "number"). */
+export const jsonTypeOf = (value) => {
+    if (value === undefined)
+        return "undefined";
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    switch (typeof value) {
+        case "string":
+            return "string";
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        default:
+            return "object";
+    }
+};
+/** Own enumerable keys, skipping prototype keys; [] for anything that is not an object. */
+export const safeKeys = (value) => isPlainObject(value) ? Object.keys(value).filter((key) => !PROTOTYPE_KEYS.has(key)) : [];
+/** Structural equality for JSON values (used by uniqueItems, Q-VAL-6). */
+export const deepEqual = (a, b) => {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b || a === null || b === null || typeof a !== "object") {
+        return Number.isNaN(a) && Number.isNaN(b);
+    }
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (Array.isArray(a)) {
+        const other = b;
+        return a.length === other.length && a.every((item, index) => deepEqual(item, other[index]));
+    }
+    const left = a;
+    const right = b;
+    const keys = Object.keys(left);
+    return keys.length === Object.keys(right).length && keys.every((key) => hasOwn(right, key) && deepEqual(left[key], right[key]));
+};
+/**
+ * How many levels of schema nesting (object schemas inside `properties`) the RAW core follows before it stops with
+ * REF_DEPTH_EXCEEDED. Real forms nest a handful of levels; this only bounds hostile or generated input (BUG-110).
+ */
+export const MAX_SCHEMA_DEPTH = 128;

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

@@ -0,0 +1,47 @@
+import { ignoreIssues, issue } from "./issues";
+import { getSchemaType } from "./schemaType";
+import { hasOwn, MAX_SCHEMA_DEPTH, PROTOTYPE_KEYS } from "./json";
+// Each schema level merges `properties` and then the property: two recursive calls per level.
+const MAX_MERGE_DEPTH = MAX_SCHEMA_DEPTH * 2;
+const isMergeable = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/**
+ * Never overflows the stack (BUG-110, Q-PP-3): a pair of objects that contains itself is cut with REF_CYCLE, nesting
+ * deeper than the limit with REF_DEPTH_EXCEEDED. The cut value is `{}`, so the result is always acyclic.
+ */
+export const mergeSchemas = (left, right, sink = ignoreIssues) => merge(left, right, sink, []);
+const merge = (left, right, sink, ancestors) => {
+    if (ancestors.length >= MAX_MERGE_DEPTH) {
+        sink(issue("REF_DEPTH_EXCEEDED"));
+        return {};
+    }
+    if (ancestors.some(([l, r]) => l === left && r === right)) {
+        sink(issue("REF_CYCLE"));
+        return {};
+    }
+    const path = [...ancestors, [left, right]];
+    const result = {};
+    if (isMergeable(left)) {
+        for (const key of Object.keys(left))
+            if (!PROTOTYPE_KEYS.has(key))
+                result[key] = left[key];
+    }
+    if (!isMergeable(right))
+        return result;
+    const objectSchema = getSchemaType(left) === "object" || getSchemaType(right) === "object";
+    for (const key of Object.keys(right)) {
+        if (PROTOTYPE_KEYS.has(key))
+            continue;
+        const l = isMergeable(left) ? left[key] : undefined;
+        const r = right[key];
+        if (isMergeable(left) && hasOwn(left, key) && isMergeable(r)) {
+            result[key] = merge(l, r, sink, path);
+        }
+        else if (objectSchema && key === "required" && Array.isArray(l) && Array.isArray(r)) {
+            result[key] = [...new Set([...l, ...r])];
+        }
+        else {
+            result[key] = r;
+        }
+    }
+    return result;
+};