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

package/dist/cjs/v3/raw/validation/arrays.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAnyOfArraySchema = exports.buildArraySchema = void 0;
+// Array validation through the shared normaliser (A11 / Q10 N-1, D2 Q-VAL-5).
+// Replaces the global `Yup.addMethod(Yup.array, "mixedOf")` of 2.x
+// (createValidationSchema.ts:45), so importing the RAW core mutates nothing.
+const Yup = __importStar(require("yup"));
+const arrays_1 = require("../core/arrays");
+const keywords_1 = require("./keywords");
+const buildArraySchema = (schema, ctx) => {
+    const { msg, ui, required } = ctx;
+    const norm = (0, arrays_1.normalizeArraySchema)(schema, ctx.sink, ctx.path);
+    const constrained = norm.fixed.length > 0 || norm.tail !== undefined;
+    const finish = (s) => {
+        let out = (0, keywords_1.applyArrayKeywords)(s, schema, ui, msg);
+        if (required)
+            out = out.required(msg("required", ui));
+        return out;
+    };
+    if (!constrained)
+        return finish(Yup.array());
+    return Yup.lazy((value) => {
+        if (!Array.isArray(value) || value.length === 0) {
+            // Wrong-typed data is a validation error, never a throw (BUG-109).
+            return finish(Yup.array().typeError(msg("required", ui)));
+        }
+        const schemas = value.map((item, index) => {
+            const target = (0, arrays_1.itemSchema)(norm, index, item).schema;
+            return target ? ctx.item(target) : Yup.mixed();
+        });
+        return finish(Yup.tuple(schemas).typeError(msg("required", ui)));
+    });
+};
+exports.buildArraySchema = buildArraySchema;
+/** 2.x `type: array` + `anyOf` (multi-select): every value must be one of the consts. */
+const buildAnyOfArraySchema = (schema, ctx) => {
+    const { msg, ui, required } = ctx;
+    if (!schema.items && !schema.additionalItems)
+        return Yup.array();
+    const allowed = (schema.anyOf ?? []).map((option) => option?.const);
+    const base = Yup.array().of(Yup.mixed().oneOf(allowed));
+    // In 2.x a required multi-select needs at least one item; kept.
+    return required ? base.min(1, msg("required", ui)) : base;
+};
+exports.buildAnyOfArraySchema = buildAnyOfArraySchema;

package/dist/cjs/v3/raw/validation/conditions.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConditionalValidations = getConditionalValidations;
+const json_1 = require("../core/json");
+const conditionals_1 = require("../core/conditionals");
+function getConditionalValidations(schema) {
+    const result = [];
+    if ((0, json_1.isPlainObject)(schema.dependencies)) {
+        for (const [key, dependency] of Object.entries(schema.dependencies)) {
+            if (!(0, json_1.isPlainObject)(dependency))
+                continue;
+            const oneOf = dependency.oneOf;
+            if (Array.isArray(oneOf)) {
+                for (const option of oneOf) {
+                    if (!(0, json_1.isPlainObject)(option))
+                        continue;
+                    const { [key]: checked, ...others } = (option.properties ?? {});
+                    if (Object.keys(others).length || Object.keys(option).length > 1) {
+                        result.push({
+                            schema: { ...option, properties: others },
+                            condition: { dependentKeys: [key], conditionFn: (value) => value === (0, conditionals_1.resolveOneOfValue)(checked) },
+                        });
+                    }
+                }
+                continue;
+            }
+            result.push({
+                schema: dependency,
+                condition: { dependentKeys: [key], conditionFn: (value) => value !== undefined && value !== "" },
+            });
+        }
+    }
+    if (Array.isArray(schema.allOf)) {
+        for (const entry of schema.allOf) {
+            if (!(0, json_1.isPlainObject)(entry))
+                continue;
+            const { if: expression, then, else: otherwise, ...rest } = entry;
+            if (!(0, json_1.isPlainObject)(expression) || !(0, json_1.isPlainObject)(expression.properties)) {
+                result.push({ schema: rest });
+                continue;
+            }
+            const expected = {};
+            for (const [k, v] of Object.entries(expression.properties)) {
+                if ((0, json_1.isPlainObject)(v))
+                    expected[k] = v.const;
+            }
+            const keys = Object.keys(expected);
+            if ((0, json_1.isPlainObject)(then)) {
+                result.push({
+                    schema: then,
+                    condition: { dependentKeys: keys, conditionFn: (...values) => values.every((v, i) => expected[keys[i]] === v) },
+                });
+            }
+            if ((0, json_1.isPlainObject)(otherwise)) {
+                result.push({
+                    schema: otherwise,
+                    condition: { dependentKeys: keys, conditionFn: (...values) => values.some((v, i) => expected[keys[i]] !== v) },
+                });
+            }
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidationSchema = createValidationSchema;
+// createValidationSchema for v3 (V-A: Yup, no global addMethod). Same signature and
+// messages as 2.x. Fixed: Q-VAL-2 ("" counts as absent), Q-VAL-4 (type-less fields
+// and type arrays), Q-VAL-5 (arrays via the shared normaliser, `required` applies),
+// Q-VAL-6, SEC-4/5 (patterns), SEC-REF-2 (cyclic `$ref` through properties). Kept:
+// Q-VAL-1, Q-VAL-7, Q-VAL-8. Never throws on wrong-typed data (BUG-109).
+const Yup = __importStar(require("yup"));
+const json_1 = require("../core/json");
+const issues_1 = require("../core/issues");
+const refs_1 = require("../core/refs");
+const trail_1 = require("../core/trail");
+const schemaType_1 = require("../core/schemaType");
+const arrays_1 = require("./arrays");
+const conditions_1 = require("./conditions");
+const keywords_1 = require("./keywords");
+const messages_1 = require("./messages");
+/** Key 2.x used for array items (no uiSchema lookup, no condition registration). */
+const ITEM_KEY = "#ignore-this";
+const emptyToUndefined = (value, original) => (original === "" ? undefined : value);
+/**
+ * Yup's object cast looks data keys up in its `fields` object, so a DATA key named
+ * like an Object.prototype member ("toString", "constructor", "__proto__", ...) finds
+ * a function and throws "field.resolve is not a function" (2.x too). Such keys are
+ * dropped from the value that is validated, unless the schema declares them.
+ */
+const withoutInheritedKeys = (declared) => (value) => {
+    if (!(0, json_1.isPlainObject)(value))
+        return value;
+    const unsafe = Object.keys(value).filter((k) => !declared.includes(k) && (json_1.PROTOTYPE_KEYS.has(k) || k in Object.prototype));
+    if (unsafe.length === 0)
+        return value;
+    const copy = {};
+    for (const k of Object.keys(value))
+        if (!unsafe.includes(k))
+            copy[k] = value[k];
+    return copy;
+};
+const baseFor = (type) => {
+    switch (type) {
+        case "object":
+            return Yup.object().transform(withoutInheritedKeys([]));
+        case "array":
+            return Yup.array();
+        case "boolean":
+            return Yup.boolean().transform(emptyToUndefined);
+        case "integer":
+        case "number":
+            return Yup.number().transform(emptyToUndefined);
+        case "null": // 2.x validated `null` as a string and its `.nullable()` call was a no-op; kept
+        case "string":
+            return Yup.string().transform(emptyToUndefined);
+        default:
+            return Yup.mixed();
+    }
+};
+function createValidationSchema(schemas, options = {}) {
+    const { schema, uiSchema = {} } = schemas;
+    const { localize, translate, definitions, defs: rootDefs, conditionsContext = {}, condition, refChain = [], trail = [] } = options;
+    // The conditions registered so far, by property key. Array items are built lazily on every validation, so they
+    // register into a copy that is dropped afterwards (Q-PERF-1): the registrations never grow with validations.
+    let active = conditionsContext;
+    const sink = options.sink ?? issues_1.ignoreIssues;
+    if (!(0, json_1.isPlainObject)(schema) || !(0, json_1.isPlainObject)(schema.properties))
+        return Yup.object().shape({}).transform(withoutInheritedKeys([]));
+    if (!(0, trail_1.mayEnter)(schema, trail, sink, ""))
+        return Yup.object().shape({}).transform(withoutInheritedKeys([]));
+    const inside = [...trail, schema];
+    const msg = (0, messages_1.makeMessage)({ localize, translate });
+    const defs = (definitions ?? schema.definitions ?? {});
+    const $defs = (rootDefs ?? ((0, json_1.isPlainObject)(schema.$defs) ? schema.$defs : undefined));
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    const nested = (s, ui, chain, extra = {}) => createValidationSchema({ schema: s, uiSchema: ui }, { localize, translate, definitions: defs, defs: $defs, conditionsContext: active, sink, refChain: chain, trail: inside, ...extra });
+    /** Runs `build` with a private copy of the registered conditions (restored afterwards, also when it throws). */
+    function scoped(build) {
+        const outer = active;
+        active = Object.fromEntries(Object.entries(outer).map(([key, list]) => [key, [...list]]));
+        try {
+            return build();
+        }
+        finally {
+            active = outer;
+        }
+    }
+    function valueSchema(given, key, isRequired, chain, scope = inside) {
+        const ref = (0, json_1.isPlainObject)(given) && typeof given.$ref === "string" ? given.$ref : undefined;
+        if (ref && chain.includes(ref)) {
+            sink((0, issues_1.issue)("REF_CYCLE", key, ref));
+            return Yup.mixed();
+        }
+        const nextChain = ref ? [...chain, ref] : chain;
+        const { schema: solved } = (0, refs_1.resolveRefs)(given, {}, { definitions: defs, defs: $defs, sink, path: key });
+        const ui = uiSchema?.[key];
+        const { type, nullable } = (0, schemaType_1.normaliseType)(solved);
+        let yup;
+        if ((0, json_1.isPlainObject)(solved.properties))
+            yup = nested(solved, ui, nextChain, { trail: scope });
+        else if (type === "array" && solved.anyOf)
+            yup = (0, arrays_1.buildAnyOfArraySchema)(solved, { msg, ui, required: isRequired });
+        else if (type === "array") {
+            // Items are validated lazily (data-bounded recursion), so the eager chain and the trail reset.
+            const item = (s) => Yup.lazy(() => scoped(() => valueSchema(s, ITEM_KEY, true, [], [])));
+            return finishConditional((0, arrays_1.buildArraySchema)(solved, { item, msg, ui, required: isRequired, sink, path: key }), solved, key);
+        }
+        else
+            yup = baseFor(type);
+        if (nullable && yup.nullable)
+            yup = yup.nullable();
+        if (type === "string")
+            yup = (0, keywords_1.applyStringKeywords)(yup, solved, ui, msg, sink, key);
+        if (type === "number" || type === "integer")
+            yup = (0, keywords_1.applyNumberKeywords)(yup, solved, ui, msg);
+        yup = (0, keywords_1.applyValueKeywords)(yup, solved, ui, msg);
+        if (isRequired)
+            yup = yup.required(msg("required", ui));
+        return finishConditional(yup, solved, key);
+    }
+    function finishConditional(yup, solved, key) {
+        if (!condition)
+            return yup;
+        if (key === ITEM_KEY) {
+            // 2.x wrapped array items in `when` too, but their keys resolve against the array
+            // (always undefined) and it re-registered them on every validation run, so the
+            // schema grew per keystroke. v3 evaluates that outcome once, with no registration.
+            return condition.conditionFn(...condition.dependentKeys.map(() => undefined)) ? yup : baseFor((0, schemaType_1.normaliseType)(solved).type);
+        }
+        const existing = (0, json_1.hasOwn)(active, key) ? active[key] : [];
+        active[key] = [...existing, { yupSchema: yup, condition }];
+        const typed = baseFor((0, schemaType_1.normaliseType)(solved).type).when(condition.dependentKeys, { is: condition.conditionFn, then: () => yup });
+        return existing.reduce((result, ctx) => result.when(ctx.condition.dependentKeys, { is: ctx.condition.conditionFn, then: () => ctx.yupSchema }), typed);
+    }
+    let result = Yup.object().shape({});
+    for (const key of Object.keys(schema.properties)) {
+        if (json_1.PROTOTYPE_KEYS.has(key)) {
+            sink((0, issues_1.issue)("KEY_REJECTED", key));
+            continue;
+        }
+        const child = schema.properties[key];
+        if (!(0, json_1.isPlainObject)(child))
+            continue;
+        result = result.concat(Yup.object().shape({ [key]: valueSchema(child, key, required.includes(key), refChain) }));
+    }
+    for (const conditional of (0, conditions_1.getConditionalValidations)(schema)) {
+        const { schema: solved } = (0, refs_1.resolveRefs)(conditional.schema, {}, { definitions: defs, defs: $defs, sink });
+        result = result.concat(nested(solved, uiSchema, refChain, { condition: conditional.condition }));
+    }
+    return result.transform(withoutInheritedKeys(Object.keys(schema.properties).filter((k) => !json_1.PROTOTYPE_KEYS.has(k))));
+}

package/dist/cjs/v3/raw/validation/keywords.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyValueKeywords = exports.applyArrayKeywords = exports.applyNumberKeywords = exports.applyStringKeywords = void 0;
+// JSON Schema keyword -> Yup tests, per type. Same messages and params as 2.x.
+const Yup = __importStar(require("yup"));
+const json_1 = require("../core/json");
+const patterns_1 = require("./patterns");
+const applyStringKeywords = (base, schema, ui, msg, sink, path) => {
+    let s = base;
+    if (schema.minLength !== undefined)
+        s = s.min(schema.minLength, msg("minLength", ui, { limit: schema.minLength }));
+    if (schema.maxLength !== undefined)
+        s = s.max(schema.maxLength, msg("maxLength", ui, { limit: schema.maxLength }));
+    const regex = (0, patterns_1.compilePattern)(schema.pattern, sink, path);
+    if (regex) {
+        const cap = schema.maxLength ?? patterns_1.DEFAULT_PATTERN_INPUT_CAP;
+        s = s.test("pattern", msg("pattern", ui), (value) => (0, patterns_1.testPattern)(regex, value, cap));
+    }
+    return s;
+};
+exports.applyStringKeywords = applyStringKeywords;
+const applyNumberKeywords = (base, schema, ui, msg) => {
+    let s = base;
+    if (schema.minimum !== undefined)
+        s = s.min(schema.minimum, msg("minimum", ui, { min: schema.minimum }));
+    if (schema.maximum !== undefined)
+        s = s.max(schema.maximum, msg("maximum", ui, { max: schema.maximum }));
+    if (typeof schema.exclusiveMinimum === "number") {
+        s = s.moreThan(schema.exclusiveMinimum, msg("exclusiveMinimum", ui, { min: schema.exclusiveMinimum }));
+    }
+    if (typeof schema.exclusiveMaximum === "number") {
+        s = s.lessThan(schema.exclusiveMaximum, msg("exclusiveMaximum", ui, { max: schema.exclusiveMaximum }));
+    }
+    if (typeof schema.multipleOf === "number") {
+        const step = schema.multipleOf;
+        s = s.test("multipleOf", msg("multipleOf", ui, { multipleOf: step }), (v) => v === undefined || v === null || v % step === 0);
+    }
+    return s;
+};
+exports.applyNumberKeywords = applyNumberKeywords;
+/** minItems / maxItems / uniqueItems (Q-VAL-6: deep equality instead of Set identity). */
+const applyArrayKeywords = (base, schema, ui, msg) => {
+    let s = base;
+    const length = (v) => (Array.isArray(v) ? v.length : undefined);
+    if (schema.minItems !== undefined) {
+        const min = schema.minItems;
+        s = s.test("minItems", msg("minItems", ui, { min }), (v) => length(v) === undefined || length(v) >= min);
+    }
+    if (schema.maxItems !== undefined) {
+        const max = schema.maxItems;
+        s = s.test("maxItems", msg("maxItems", ui, { max }), (v) => length(v) === undefined || length(v) <= max);
+    }
+    if (schema.uniqueItems === true) {
+        s = s.test("uniqueItems", msg("uniqueItems", ui), (v) => !Array.isArray(v) || v.every((item, i) => v.findIndex((other) => (0, json_1.deepEqual)(item, other)) === i));
+    }
+    return s;
+};
+exports.applyArrayKeywords = applyArrayKeywords;
+/** enum / const (incl. `{ $data }`, Q-VAL-7 kept: last pointer segment) / not.const. */
+const applyValueKeywords = (base, schema, ui, msg) => {
+    let s = base;
+    if (schema.enum !== undefined || schema.const !== undefined) {
+        const constValue = schema.const;
+        if (constValue !== null && typeof constValue === "object" && typeof constValue.$data === "string") {
+            const parts = constValue.$data.split("/");
+            s = s.oneOf([Yup.ref(parts[parts.length - 1])], msg("const", ui));
+        }
+        else if (schema.const !== undefined) {
+            s = s.oneOf([schema.const], msg("const", ui));
+        }
+        else if (Array.isArray(schema.enum)) {
+            s = s.oneOf(schema.enum, msg("enum", ui));
+        }
+    }
+    const not = schema.not;
+    if (not && typeof not === "object" && not.const !== undefined)
+        s = s.notOneOf([not.const], msg("notConst", ui));
+    return s;
+};
+exports.applyValueKeywords = applyValueKeywords;

package/dist/cjs/v3/raw/validation/messages.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMessage = void 0;
+const i18n_1 = require("../i18n");
+const english = (0, i18n_1.createTranslator)("en");
+const makeMessage = ({ localize, translate = english }) => (keyword, fieldUiSchema, params) => {
+    const custom = fieldUiSchema?.["ui:validation"]?.error?.[keyword];
+    if (custom)
+        return custom;
+    if (localize)
+        return localize(`validation.error.${keyword}`, params);
+    return translate(`validation.error.${keyword}`, params);
+};
+exports.makeMessage = makeMessage;

package/dist/cjs/v3/raw/validation/patterns.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testPattern = exports.compilePattern = exports.isUnsafePattern = exports.DEFAULT_PATTERN_INPUT_CAP = void 0;
+const issues_1 = require("../core/issues");
+/** Values longer than this are not run through a pattern (they fail it instead). */
+exports.DEFAULT_PATTERN_INPUT_CAP = 10_000;
+// Heuristics for catastrophic backtracking (not a full analyser; plan B-34 names
+// recheck / safe-regex2 for later). Rejected:
+// 1. a quantified group that itself contains a quantifier: (a+)+, (\w*)*, (x+){2,};
+// 2. a quantified group whose alternatives can overlap: (a|aa)+, (a|a)*, (.|x)+.
+// Benign patterns such as ^[a-z]+$, ^(\+358|0)\d+$ or ^([A-Z]|[0-9])+$ pass.
+const NESTED_QUANTIFIER = /\((?:[^()\\]|\\.)*[*+}](?:[^()\\]|\\.)*\)\s*(?:[*+]|\{\d+,\d*\})/;
+const QUANTIFIED_GROUP = /\(((?:[^()\\]|\\.)*\|(?:[^()\\]|\\.)*)\)\s*(?:[*+]|\{\d+,\d*\})/g;
+const WILDCARD_START = /^(?:\.|\\[wWsSdD])/;
+/** Splits on top-level `|`, keeping escapes and character classes intact. */
+const alternatives = (body) => {
+    const parts = [];
+    let current = "";
+    let inClass = false;
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        if (ch === "\\") {
+            current += ch + (body[i + 1] ?? "");
+            i++;
+        }
+        else if (ch === "[" || ch === "]") {
+            inClass = ch === "[" ? true : false;
+            current += ch;
+        }
+        else if (ch === "|" && !inClass) {
+            parts.push(current);
+            current = "";
+        }
+        else
+            current += ch;
+    }
+    return [...parts, current].map((p) => p.replace(/^\?:/, ""));
+};
+const alternativesOverlap = (alts) => alts.some((a, i) => WILDCARD_START.test(a) || alts.some((b, j) => i !== j && (a === "" || b.startsWith(a))));
+const isUnsafePattern = (pattern) => {
+    if (NESTED_QUANTIFIER.test(pattern))
+        return true;
+    for (const match of pattern.matchAll(QUANTIFIED_GROUP)) {
+        if (alternativesOverlap(alternatives(match[1])))
+            return true;
+    }
+    return false;
+};
+exports.isUnsafePattern = isUnsafePattern;
+/** A compiled pattern, or undefined when it is invalid or rejected (the keyword is skipped). */
+const compilePattern = (pattern, sink, path) => {
+    if (typeof pattern !== "string")
+        return undefined;
+    if ((0, exports.isUnsafePattern)(pattern)) {
+        sink((0, issues_1.issue)("PATTERN_REJECTED", path, pattern));
+        return undefined;
+    }
+    try {
+        return new RegExp(pattern); // unanchored search, like JSON Schema (Q-VAL-1, kept)
+    }
+    catch {
+        sink((0, issues_1.issue)("PATTERN_INVALID", path, pattern));
+        return undefined;
+    }
+};
+exports.compilePattern = compilePattern;
+/** Q-VAL-1 semantics with an input cap: over-long values never reach the regex. */
+const testPattern = (regex, value, cap) => {
+    if (value === undefined || value === null || value === "")
+        return true;
+    const text = String(value);
+    return text.length <= cap && regex.test(text);
+};
+exports.testPattern = testPattern;

package/dist/cjs/v3/react/chain.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainContext = void 0;
+// The $refs being expanded above a React boundary (SEC-REN-1 / SEC-REF-2 across custom templates
+// and fields), shared by FormView and Form.
+const react_1 = require("react");
+exports.ChainContext = (0, react_1.createContext)([]);

package/dist/cjs/v3/react/compat.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormWrapper = exports.COMPONENT_TYPES = void 0;
+// 2.x root names with no other v3 home (C1, kept until 4.0).
+const react_1 = require("react");
+const dispatch_1 = require("../raw/model/form/dispatch");
+const selector_1 = require("./selector");
+/** 2.x SchemaField's schema type -> field name table. */
+exports.COMPONENT_TYPES = Object.freeze({ ...dispatch_1.COMPONENT_TYPES });
+/** 2.x FormView's outer wrapper (a styled div), as a compat primitive with its `fjsf-view-FormWrapper` class. */
+exports.FormWrapper = (0, selector_1.asStyledSelector)((0, react_1.forwardRef)(({ className, ...props }, ref) => (0, react_1.createElement)("div", { ...props, ref, className: ["fjsf-view-FormWrapper", className].filter(Boolean).join(" ") })), "div", ["fjsf-view-FormWrapper"]);

package/dist/cjs/v3/react/componentsProp.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetComponentsPropWarning = exports.warnComponentsProp = exports.COMPONENTS_PROP_WARNING = void 0;
+// D3 / Q-COMP-1: 2.x's `components` prop is replaced by `slots`. A leftover `components` is a type error
+// (FormProps / FormViewProps declare it `never`), and at runtime it is ignored with one warning in
+// development, so a call that still forwards it (pro3's exam mode HiddenErrorMessage) is not silently dropped.
+let warned = false;
+exports.COMPONENTS_PROP_WARNING = "formik-jsonschema-form: the `components` prop is not supported in v3 and is ignored. Pass `slots` instead (each slot gets the library's component as `Default`); the fjsf-v3-codemod rewrites it.";
+/** Warns once per process when `components` is passed (not in production). */
+const warnComponentsProp = (components) => {
+    if (warned || components === undefined)
+        return;
+    if (globalThis.process?.env?.NODE_ENV === "production")
+        return;
+    warned = true;
+    globalThis.console?.error?.(exports.COMPONENTS_PROP_WARNING);
+};
+exports.warnComponentsProp = warnComponentsProp;
+/** Tests: warn again. */
+const resetComponentsPropWarning = () => {
+    warned = false;
+};
+exports.resetComponentsPropWarning = resetComponentsPropWarning;

package/dist/cjs/v3/react/defined.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defined = void 0;
+// A 2.x `Partial<FieldsType>` may carry `undefined` entries: they must not replace a built-in field.
+const defined = (map) => Object.fromEntries(Object.entries(map ?? {}).filter(([, v]) => v !== undefined));
+exports.defined = defined;

package/dist/cjs/v3/react/ejs/EJSField.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EJSField = exports.renderTemplate = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const ejs_browser_1 = __importDefault(require("ejs-browser"));
+const formik_1 = require("formik");
+const issues_1 = require("../../raw/core/issues");
+const paths_1 = require("../../raw/core/paths");
+const uiSchema_1 = require("../../raw/core/uiSchema");
+const sanitize_1 = require("../../raw/sanitize");
+const registry_1 = require("../view/registry");
+const FIXED_ERROR = "Error rendering template.";
+const hasWindow = () => typeof globalThis.window !== "undefined";
+/** True when there is a sanitiser to put the output through (checked BEFORE the template runs). */
+const sanitiserAvailable = () => {
+    try {
+        (0, sanitize_1.sanitizeHtml)("");
+        return true;
+    }
+    catch (error) {
+        if (error instanceof sanitize_1.SanitizerUnavailableError)
+            return false;
+        throw error;
+    }
+};
+/**
+ * The final HTML of the field, or `undefined` when nothing may be rendered. The template is NOT RUN unless the output can be
+ * sanitised: no window, or a window that cannot sanitise (a shim), reports `window` / `sanitizer` first. ejs-browser
+ * templates see Node's globals (SEC-SSR-2), so a server must never execute a tenant's template, and 2.x did (it ran it,
+ * then threw SANITIZER_UNAVAILABLE). A real DOM window in a server process still runs templates: only
+ * `setSanitizerWindow` without a global window stays disabled.
+ */
+const renderTemplate = (template, scope, onIssue) => {
+    if (!hasWindow()) {
+        onIssue("window");
+        return undefined;
+    }
+    if (!sanitiserAvailable()) {
+        onIssue("sanitizer");
+        return undefined;
+    }
+    let rendered;
+    try {
+        rendered = ejs_browser_1.default.render(String(template), scope);
+    }
+    catch {
+        // SEC-EJS-4: an error becomes a fixed string; v3 also reports it
+        onIssue("error");
+        rendered = FIXED_ERROR;
+    }
+    return (0, sanitize_1.sanitizeHtml)(rendered);
+};
+exports.renderTemplate = renderTemplate;
+const EJSField = (props) => {
+    const { components } = (0, react_1.useContext)(registry_1.FormViewRegistry);
+    const { sink } = (0, react_1.useContext)(registry_1.ViewRootContext);
+    const { name, uiSchema = {} } = props;
+    const values = (0, formik_1.useFormikContext)()?.values;
+    const title = (0, uiSchema_1.getTitle)(props) || "Untitled Field";
+    const description = (0, uiSchema_1.getDescription)(props) || "No description available.";
+    const template = uiSchema["ui:options"]?.template ?? "No template provided.";
+    const value = (0, paths_1.getIn)(values, name);
+    const html = (0, react_1.useMemo)(() => (0, exports.renderTemplate)(template, { title, description, value }, (detail) => sink?.((0, issues_1.issue)("TEMPLATE_DISABLED", name, detail))), 
+    // the sink is the host's reporting channel, not an input of the output
+    [template, title, description, name, value]);
+    if (html === undefined)
+        return null;
+    const Value = components.EJSFieldValue ?? "div";
+    return (0, jsx_runtime_1.jsx)(Value, { dangerouslySetInnerHTML: { __html: html } });
+};
+exports.EJSField = EJSField;

package/dist/cjs/v3/react/ejs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTemplate = exports.EJSField = void 0;
+// @nolwenture/formik-jsonschema-form/react/ejs (v3): the opt-in EJS field (D1, Q5).
+// Needs the optional peer `ejs-browser`. Register it explicitly: `<FormView fields={{ EJSField }} />`.
+var EJSField_1 = require("./EJSField");
+Object.defineProperty(exports, "EJSField", { enumerable: true, get: function () { return EJSField_1.EJSField; } });
+Object.defineProperty(exports, "renderTemplate", { enumerable: true, get: function () { return EJSField_1.renderTemplate; } });