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

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSchema = exports.deepOverlap = void 0;
+exports.resolveOneOfValue = resolveOneOfValue;
+const json_1 = require("./json");
+const merge_1 = require("./merge");
+/** 2.x deepOverlap: every key of `a` is present in `b` with an equal (or overlapping) value. */
+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 && !(0, exports.deepOverlap)(left, right)) || (!bothObjects && left !== right))
+            return false;
+    }
+    return true;
+};
+exports.deepOverlap = deepOverlap;
+function resolveOneOfValue(value) {
+    if (value === true || value === false)
+        return value;
+    if ((0, json_1.isSchemaObject)(value) && value.enum?.[0] !== undefined)
+        return value.enum[0];
+    return undefined;
+}
+const resolveEquality = (value, expression) => {
+    const properties = {};
+    for (const key of (0, json_1.safeKeys)(value))
+        properties[key] = { const: value[key] };
+    return (0, exports.deepOverlap)(expression, { properties });
+};
+const selectedOneOf = (key, value, oneOf) => {
+    const match = (oneOf.find((one) => (0, json_1.isPlainObject)(one) && (0, json_1.isPlainObject)(one.properties)
+        ? resolveOneOfValue(one.properties[key]) === value[key]
+        : false) ?? {});
+    const properties = {};
+    for (const inner of (0, json_1.safeKeys)(match.properties)) {
+        if (inner !== key)
+            properties[inner] = match.properties[inner];
+    }
+    return { ...match, properties };
+};
+/** Same contract as 2.x resolveSchema: `[resolvedSchema, keysToPrune]`. */
+const resolveSchema = (input, rawValue) => {
+    const value = (0, json_1.isPlainObject)(rawValue) ? rawValue : {};
+    const { allOf, dependencies, ...schema } = (0, json_1.isPlainObject)(input) ? input : {};
+    let resolved = schema;
+    const pruneDeps = [];
+    if ((0, json_1.isPlainObject)(dependencies)) {
+        for (const [key, dependency] of Object.entries(dependencies)) {
+            if (value[key] === undefined || value[key] === "" || !(0, json_1.isPlainObject)(dependency))
+                continue;
+            const oneOf = dependency.oneOf;
+            resolved = (0, merge_1.mergeSchemas)(resolved, Array.isArray(oneOf) ? selectedOneOf(key, value, oneOf) : dependency);
+        }
+        const used = Object.keys(resolved.properties ?? {});
+        for (const key of (0, json_1.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 (!(0, json_1.isPlainObject)(current))
+            continue;
+        const { if: expression, then, else: otherwise, ...rest } = current;
+        if (!(0, json_1.isPlainObject)(expression)) {
+            resolved = (0, merge_1.mergeSchemas)(resolved, rest);
+            continue;
+        }
+        const matches = resolveEquality(value, expression);
+        const taken = matches ? then : otherwise;
+        const skipped = matches ? otherwise : then;
+        if ((0, json_1.isPlainObject)(taken))
+            resolved = (0, merge_1.mergeSchemas)(resolved, taken);
+        if ((0, json_1.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])]];
+};
+exports.resolveSchema = resolveSchema;

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatForDisplay = exports.preferOrderOf = exports.parseDateString = exports.isValidYMD = exports.toIsoDateString = void 0;
+const toIsoDateString = (date) => date.toISOString().slice(0, 10);
+exports.toIsoDateString = toIsoDateString;
+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;
+};
+exports.isValidYMD = isValidYMD;
+const ymd = (y, m, d) => ((0, exports.isValidYMD)(y, m, d) ? new Date(Date.UTC(y, m - 1, d)) : undefined);
+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 && (0, exports.isValidYMD)(+mm[3], +mm[2], +mm[1]))
+            return ymd(+mm[3], +mm[2], +mm[1]);
+    }
+    return undefined;
+};
+exports.parseDateString = parseDateString;
+/** The day/month order of the locale's date format. */
+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";
+    }
+};
+exports.preferOrderOf = preferOrderOf;
+/** What the display input shows for a stored value (2.x formatForDisplay; `"now"` shows today). */
+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)
+    }
+};
+exports.formatForDisplay = formatForDisplay;

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

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

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSelectedEnum = exports.getEnums = exports.EnumsTypes = void 0;
+const issues_1 = require("./issues");
+var EnumsTypes;
+(function (EnumsTypes) {
+    EnumsTypes["SELECT"] = "select";
+    EnumsTypes["MULTI_SELECT"] = "multiSelect";
+})(EnumsTypes || (exports.EnumsTypes = EnumsTypes = {}));
+const getEnums = ({ schema }, sink = issues_1.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((0, issues_1.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 : []) };
+};
+exports.getEnums = getEnums;
+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;
+};
+exports.getSelectedEnum = getSelectedEnum;

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitialValues = createInitialValues;
+const json_1 = require("./json");
+const issues_1 = require("./issues");
+const optionalNumberInitial_1 = require("./policies/optionalNumberInitial");
+const refs_1 = require("./refs");
+const schemaType_1 = require("./schemaType");
+const trail_1 = require("./trail");
+const OMIT = Symbol("omit");
+function createInitialValues(schema, definitions = {}, options = {}) {
+    const sink = options.sink ?? issues_1.ignoreIssues;
+    if (!(0, json_1.isPlainObject)(schema) || !(0, json_1.isPlainObject)(schema.properties))
+        return {};
+    const defs = { ...definitions, ...((0, json_1.isPlainObject)(schema.definitions) ? schema.definitions : {}) };
+    const $defs = (0, json_1.isPlainObject)(schema.$defs) ? schema.$defs : undefined;
+    const valueOf = (node, required, path, chain, trail) => {
+        const ref = (0, json_1.isPlainObject)(node) && typeof node.$ref === "string" ? node.$ref : undefined;
+        if (ref && chain.includes(ref)) {
+            sink((0, issues_1.issue)("REF_CYCLE", path, ref));
+            return OMIT;
+        }
+        const nextChain = ref ? [...chain, ref] : chain;
+        const { schema: solved } = (0, refs_1.resolveRefs)(node, {}, { definitions: defs, defs: $defs, sink, path });
+        if ((0, json_1.isPlainObject)(solved.properties))
+            return (0, trail_1.mayEnter)(solved, trail, sink, path) ? objectOf(solved, path, nextChain, trail) : OMIT;
+        const { type } = (0, schemaType_1.normaliseType)(solved);
+        switch (type) {
+            case "object":
+                return {};
+            case "array":
+                return [];
+            case "number":
+            case "integer": {
+                if (required)
+                    return 0;
+                const initial = (0, optionalNumberInitial_1.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 (json_1.PROTOTYPE_KEYS.has(key)) {
+                sink((0, issues_1.issue)("KEY_REJECTED", childPath));
+                continue;
+            }
+            const child = node.properties[key];
+            if (!(0, json_1.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/cjs/v3/raw/core/issues.js

@@ -0,0 +1,42 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectIssues = exports.issue = exports.ignoreIssues = exports.ISSUE_CODES = void 0;
+exports.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. */
+const ignoreIssues = () => undefined;
+exports.ignoreIssues = ignoreIssues;
+const WARNINGS = new Set(["SCHEMA_ARRAY_AMBIGUOUS", "SCHEMA_ENUM_CONFLICT", "KEY_AMBIGUOUS", "FIELD_UNKNOWN"]);
+const issue = (code, path, detail) => ({
+    code,
+    severity: WARNINGS.has(code) ? "warning" : "error",
+    ...(path === undefined ? {} : { path }),
+    ...(detail === undefined ? {} : { detail }),
+});
+exports.issue = issue;
+/** Collects issues into an array (tests and the controller use this). */
+const collectIssues = () => {
+    const issues = [];
+    return { sink: (i) => issues.push(i), issues };
+};
+exports.collectIssues = collectIssues;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SCHEMA_DEPTH = exports.deepEqual = exports.safeKeys = exports.jsonTypeOf = exports.isSchemaObject = exports.isPlainObject = exports.hasOwn = exports.PROTOTYPE_KEYS = void 0;
+/** Keys that must never be read or written as data/schema keys (SEC-8, SEC-10). */
+exports.PROTOTYPE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+const hasOwn = (value, key) => value !== null && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key);
+exports.hasOwn = hasOwn;
+const isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+exports.isPlainObject = isPlainObject;
+const isSchemaObject = (value) => (0, exports.isPlainObject)(value);
+exports.isSchemaObject = isSchemaObject;
+/** JSON type name of a runtime value ("integer" is reported as "number"). */
+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";
+    }
+};
+exports.jsonTypeOf = jsonTypeOf;
+/** Own enumerable keys, skipping prototype keys; [] for anything that is not an object. */
+const safeKeys = (value) => (0, exports.isPlainObject)(value) ? Object.keys(value).filter((key) => !exports.PROTOTYPE_KEYS.has(key)) : [];
+exports.safeKeys = safeKeys;
+/** Structural equality for JSON values (used by uniqueItems, Q-VAL-6). */
+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) => (0, exports.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) => (0, exports.hasOwn)(right, key) && (0, exports.deepEqual)(left[key], right[key]));
+};
+exports.deepEqual = deepEqual;
+/**
+ * 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).
+ */
+exports.MAX_SCHEMA_DEPTH = 128;

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSchemas = void 0;
+const issues_1 = require("./issues");
+const schemaType_1 = require("./schemaType");
+const json_1 = require("./json");
+// Each schema level merges `properties` and then the property: two recursive calls per level.
+const MAX_MERGE_DEPTH = json_1.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.
+ */
+const mergeSchemas = (left, right, sink = issues_1.ignoreIssues) => merge(left, right, sink, []);
+exports.mergeSchemas = mergeSchemas;
+const merge = (left, right, sink, ancestors) => {
+    if (ancestors.length >= MAX_MERGE_DEPTH) {
+        sink((0, issues_1.issue)("REF_DEPTH_EXCEEDED"));
+        return {};
+    }
+    if (ancestors.some(([l, r]) => l === left && r === right)) {
+        sink((0, issues_1.issue)("REF_CYCLE"));
+        return {};
+    }
+    const path = [...ancestors, [left, right]];
+    const result = {};
+    if (isMergeable(left)) {
+        for (const key of Object.keys(left))
+            if (!json_1.PROTOTYPE_KEYS.has(key))
+                result[key] = left[key];
+    }
+    if (!isMergeable(right))
+        return result;
+    const objectSchema = (0, schemaType_1.getSchemaType)(left) === "object" || (0, schemaType_1.getSchemaType)(right) === "object";
+    for (const key of Object.keys(right)) {
+        if (json_1.PROTOTYPE_KEYS.has(key))
+            continue;
+        const l = isMergeable(left) ? left[key] : undefined;
+        const r = right[key];
+        if (isMergeable(left) && (0, json_1.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;
+};

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

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

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FILE_UPLOAD_VIEW = void 0;
+exports.FILE_UPLOAD_VIEW = "todo";

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionalNumberInitialValue = exports.OPTIONAL_NUMBER_INITIAL = void 0;
+exports.OPTIONAL_NUMBER_INITIAL = "absent";
+/** `undefined` means "leave the key out". */
+const optionalNumberInitialValue = (policy = exports.OPTIONAL_NUMBER_INITIAL) => policy === "zero" ? 0 : policy === "empty" ? "" : undefined;
+exports.optionalNumberInitialValue = optionalNumberInitialValue;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BOOLEAN_RADIO_STORAGE = exports.MULTI_SELECT_STORAGE = void 0;
+exports.MULTI_SELECT_STORAGE = "strings";
+exports.BOOLEAN_RADIO_STORAGE = "strings";

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

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