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

package/README.md

@@ -1,5 +1,10 @@
 # formik-jsonschema-form
 
+> **3.0.0 (on `next`):** the package root is the v3 implementation. Styling comes from `styles.css` (or
+> `getDefaultStyles()`) with `--fjsf-*` variables set by `themeToCssVars(theme)`, and `components` is replaced by
+> `slots`. To migrate, run `npx fjsf-v3-codemod <files...>` and follow `documentation/v3/07-delivery-plan.md` §7.5.
+> The usage sections below still describe 2.x styling (styled-components, `components`); they are being updated.
+
 ## Installation
 
 With npm:
@@ -14,6 +19,8 @@ With yarn:
 yarn add @nolwenture/formik-jsonschema-form
 ```
 
+The package expects `formik`, `yup` and `react` to be installed by the consuming application (peer dependencies). Load the default stylesheet with `import "@nolwenture/formik-jsonschema-form/styles.css"` (or inline `getDefaultStyles()`) before your own CSS.
+
 ## Testing
 
 Run unit tests:
@@ -22,6 +29,17 @@ Run unit tests:
 npm run test
 ```
 
+Other checks that CI runs: `npm run typecheck`, `npm run test:ci` (jest with coverage), `npm run depcheck` and `npm run build`.
+
+`npm ci && npm test` works without any registry token. The shipped library no longer uses the private `@nolwenture/component-library`; the frozen 2.x reference copy the tests compare against (`src/testing/v2-reference`) still imports its `Button`, so jest and the typecheck use stand-ins (`test-fixtures/component-library/` for jest, `@types/component-library.d.ts` for tsc). To run the tests against the real package (needs a read token for the `@nolwenture` scope):
+
+```text
+npm install --no-save --ignore-scripts @nolwenture/component-library@1.1.0
+FJSF_REAL_COMPONENT_LIBRARY=1 npm test
+```
+
+Storybook also needs the real package installed this way.
+
 To run storybook tests make sure you have Playwright installed:
 
 ```text

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

@@ -14,7 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// The public types (dist/types/common/types, a path pro3 deep-imports until 4.0).
 __exportStar(require("./Field"), exports);
 __exportStar(require("./Form"), exports);
 __exportStar(require("./Schemas"), exports);
 __exportStar(require("./Templates"), exports);
+__exportStar(require("./Utils"), exports);

package/dist/cjs/index.js

@@ -14,8 +14,18 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-//This file exists for purpose releasing "moduleResolution": "node" compatible version (until we split this to multiple packages)
-__exportStar(require("./common"), exports);
-__exportStar(require("./Form"), exports);
-__exportStar(require("./FormView"), exports);
-__exportStar(require("./utils"), exports);
+exports.FormWrapper = exports.COMPONENT_TYPES = exports.setSanitizerWindow = exports.sanitizeHtml = exports.SanitizerUnavailableError = exports.SANITIZER_UNAVAILABLE = void 0;
+// 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).
+__exportStar(require("./v3/react"), exports);
+__exportStar(require("./v3/raw/compat/v2utils"), exports);
+var sanitize_1 = require("./v3/raw/sanitize");
+Object.defineProperty(exports, "SANITIZER_UNAVAILABLE", { enumerable: true, get: function () { return sanitize_1.SANITIZER_UNAVAILABLE; } });
+Object.defineProperty(exports, "SanitizerUnavailableError", { enumerable: true, get: function () { return sanitize_1.SanitizerUnavailableError; } });
+Object.defineProperty(exports, "sanitizeHtml", { enumerable: true, get: function () { return sanitize_1.sanitizeHtml; } });
+Object.defineProperty(exports, "setSanitizerWindow", { enumerable: true, get: function () { return sanitize_1.setSanitizerWindow; } });
+__exportStar(require("./common/types"), exports);
+var compat_1 = require("./v3/react/compat");
+Object.defineProperty(exports, "COMPONENT_TYPES", { enumerable: true, get: function () { return compat_1.COMPONENT_TYPES; } });
+Object.defineProperty(exports, "FormWrapper", { enumerable: true, get: function () { return compat_1.FormWrapper; } });

package/dist/cjs/v3/codemod/bindings.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveKinds = exports.localKinds = exports.componentsSites = exports.tagEnd = exports.enclosing = void 0;
+// Which names in a file render the library's Form / FormView (`library`) and which pass their own
+// `components` on to one (`forwarder`), followed across files the way pro3 is built: wrappers declared in a
+// styledComponents file (`export const StyledForm = styled(Form)`), styled forwarders
+// (`styled(EditForm)`), aliases (`const FormComponent = examMode ? StyledExamForm : EditForm`) and relative
+// imports / re-exports. Iterated over all files until nothing changes.
+const package_1 = require("./package");
+/** The component declared before `index` (`const X =` / `function X`): the owner of a JSX site. */
+const enclosing = (source, index) => [...source.slice(0, index).matchAll(/(?:^|\n)\s*(?:export\s+)?(?:default\s+)?(?:const|let|function)\s+([A-Z]\w*)/g)].pop()?.[1];
+exports.enclosing = enclosing;
+/** The end of a JSX opening tag that starts at `from` (braces and strings balanced), or -1. */
+const tagEnd = (source, from) => {
+    let depth = 0;
+    let quote = "";
+    for (let j = from; j < source.length; j++) {
+        const c = source[j];
+        if (quote)
+            quote = c === quote ? "" : quote;
+        else if (c === '"' || c === "'" || c === "`")
+            quote = c;
+        else if (c === "{")
+            depth++;
+        else if (c === "}")
+            depth--;
+        else if (c === ">" && depth === 0)
+            return j;
+    }
+    return -1;
+};
+exports.tagEnd = tagEnd;
+/** Every `components=` in a JSX opening tag: the element, where it is, and the attribute's text. */
+const componentsSites = (source) => {
+    const sites = [];
+    const open = /<([A-Za-z][\w.]*)\b/g;
+    for (let m = open.exec(source); m; m = open.exec(source)) {
+        const end = (0, exports.tagEnd)(source, m.index + m[0].length);
+        if (end < 0)
+            break;
+        const tag = source.slice(m.index, end);
+        const attr = /(\s)components=\{/.exec(tag);
+        if (attr)
+            sites.push({ element: m[1], index: m.index, attr: m.index + attr.index, value: tag.slice(attr.index + attr[0].length) });
+        open.lastIndex = end;
+    }
+    return sites;
+};
+exports.componentsSites = componentsSites;
+/** The kinds of the names declared in one file, given the kinds of the names it imports (`known`). */
+const localKinds = (source, known = new Map()) => {
+    const kinds = new Map(known);
+    for (const m of source.matchAll(new RegExp(`import\\s*\\{([^}]*)\\}\\s*from\\s*["']${package_1.PACKAGE}["']`, "g"))) {
+        for (const spec of m[1].split(",").map((s) => s.trim())) {
+            const [imported, local] = spec.split(/\s+as\s+/).map((s) => s.trim());
+            if (imported === "Form" || imported === "FormView")
+                kinds.set(local ?? imported, "library");
+        }
+    }
+    const snapshot = () => [...kinds].map(([n, k]) => `${n}:${k}`).sort().join(",");
+    for (let before = ""; before !== snapshot();) {
+        before = snapshot();
+        for (const m of source.matchAll(/(?:const|let|var)\s+(\w+)\s*(?::[^=]+)?=\s*styled\(\s*(\w+)\s*\)/g)) {
+            const k = kinds.get(m[2]);
+            if (k && !kinds.has(m[1]))
+                kinds.set(m[1], k);
+        }
+        for (const m of source.matchAll(/(?:const|let|var)\s+(\w+)\s*(?::[^=;]+?)?=\s*(\w+)\s*(?:\?\s*(\w+)\s*:\s*(\w+))?\s*;/g)) {
+            const candidates = m[3] ? [m[3], m[4]] : [m[2]];
+            const ks = new Set(candidates.map((c) => kinds.get(c)));
+            if (ks.size === 1 && !ks.has(undefined) && !kinds.has(m[1]))
+                kinds.set(m[1], [...ks][0]);
+        }
+        // a component that passes its own `components` to a known element forwards it
+        for (const site of (0, exports.componentsSites)(source)) {
+            const owner = (0, exports.enclosing)(source, site.index);
+            if (kinds.has(site.element) && owner && !kinds.has(owner) && /\bcomponents\b/.test(site.value))
+                kinds.set(owner, "forwarder");
+        }
+    }
+    return kinds;
+};
+exports.localKinds = localKinds;
+const EXTS = ["", ".ts", ".tsx", "/index.ts", "/index.tsx"];
+const join = (file, spec) => {
+    const parts = file.split("/").slice(0, -1);
+    for (const p of spec.split("/")) {
+        if (p === "..")
+            parts.pop();
+        else if (p !== ".")
+            parts.push(p);
+    }
+    return parts.join("/");
+};
+/** The kinds of every file's names, following relative imports and re-exports between the given files. */
+const resolveKinds = (sources, wrappers = []) => {
+    const resolve = (file, spec) => EXTS.map((e) => join(file, spec) + e).find((f) => sources.has(f));
+    const kinds = new Map([...sources.keys()].map((f) => [f, new Map()]));
+    for (let changed = true, rounds = 0; changed && rounds < 50; rounds++) {
+        changed = false;
+        for (const [file, source] of sources) {
+            const known = new Map(wrappers.map((w) => [w, "library"]));
+            for (const m of source.matchAll(/(?:import|export)\s*(?:type\s+)?\{([^}]*)\}\s*from\s*["'](\.[^"']+)["']/g)) {
+                const theirs = kinds.get(resolve(file, m[2]) ?? "");
+                for (const spec of m[1].split(",").map((s) => s.trim()).filter(Boolean)) {
+                    const [imported, local] = spec.split(/\s+as\s+/).map((s) => s.trim());
+                    const k = theirs?.get(imported);
+                    if (k)
+                        known.set(local ?? imported, k);
+                }
+            }
+            for (const m of source.matchAll(/export\s*\*\s*from\s*["'](\.[^"']+)["']/g))
+                kinds.get(resolve(file, m[1]) ?? "")?.forEach((k, n) => known.set(n, k));
+            const next = (0, exports.localKinds)(source, known);
+            const prev = kinds.get(file);
+            if (next.size !== prev.size || [...next].some(([n, k]) => prev.get(n) !== k)) {
+                kinds.set(file, next);
+                changed = true;
+            }
+        }
+    }
+    return kinds;
+};
+exports.resolveKinds = resolveKinds;

package/dist/cjs/v3/codemod/cli.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+"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 });
+// fjsf-v3-codemod [--dry] [--wrappers A,B] [--allow-unhandled] <files...>: rewrites pro3 sources for v3
+// (transform.ts) and lists what it left for review: inert selectors (Q7 I-1 / F-1) and every `components=`
+// it could not rewrite. Those make it exit 1 unless --allow-unhandled. Node built-ins only.
+const fs = __importStar(require("fs"));
+const migrate_1 = require("./migrate");
+const args = process.argv.slice(2);
+const flag = (name) => args.includes(name);
+const listOption = (name) => {
+    const i = args.findIndex((a) => a === name || a.startsWith(`${name}=`));
+    if (i < 0)
+        return [];
+    const value = args[i].includes("=") ? args[i].split("=")[1] : args[i + 1] ?? "";
+    return value.split(",").map((s) => s.trim()).filter(Boolean);
+};
+const wrappers = listOption("--wrappers");
+const files = args.filter((a, i) => !a.startsWith("--") && args[i - 1] !== "--wrappers");
+if (!files.length) {
+    console.error("usage: fjsf-v3-codemod [--dry] [--wrappers A,B] [--allow-unhandled] <files...>");
+    process.exit(2);
+}
+const readable = files.filter((f) => fs.existsSync(f) && fs.statSync(f).isFile());
+for (const f of files.filter((x) => !readable.includes(x)))
+    console.log(`${f}: not a file, skipped`);
+const sources = new Map(readable.map((f) => [f, fs.readFileSync(f, "utf8")]));
+const { outputs, reports, forwarders } = (0, migrate_1.migrate)(sources, wrappers);
+const total = { files: 0, selectors: 0, slots: 0, imports: 0, inert: 0, unhandled: 0 };
+for (const [file, source] of sources) {
+    const [output, report] = [outputs.get(file), reports.get(file)];
+    if (output === source && !report.inert.length && !report.unknown.length && !report.unhandled.length && !report.kept.length)
+        continue;
+    total.files++;
+    total.selectors += report.selectors;
+    total.slots += report.slots;
+    total.imports += report.imports;
+    total.inert += report.inert.length;
+    total.unhandled += report.unhandled.length;
+    if (!flag("--dry") && output !== source)
+        fs.writeFileSync(file, output);
+    console.log(`${file}: ${report.selectors} selectors, ${report.slots} components= -> slots=, ${report.imports} imports`);
+    for (const i of report.inert)
+        console.log(`  inert (${i.reasons.join(", ")}) line ${i.line}: FormComponents.${i.name}`);
+    for (const u of report.unknown)
+        console.log(`  not a FormComponents class, left as is: ${u}`);
+    for (const k of report.kept)
+        console.log(`  ${file}:${k.line}: <${k.element} components=> kept: ${k.element} forwards it to the library as slots`);
+    for (const u of report.unhandled)
+        console.log(`  ${file}:${u.line}: <${u.element} components=> NOT rewritten: does it reach the library Form/FormView? (--wrappers ${u.element} if it passes its props through)`);
+}
+console.log(`${flag("--dry") ? "[dry] " : ""}${total.files} files: ${total.selectors} selectors, ${total.slots} slots, ${total.imports} imports, ${total.inert} inert selectors listed, ${total.unhandled} components= sites not rewritten`);
+if (forwarders.length)
+    console.log(`forwarders (their callers keep components=): ${forwarders.join(", ")}`);
+if (total.unhandled && !flag("--allow-unhandled"))
+    process.exit(1);

package/dist/cjs/v3/codemod/migrate.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = void 0;
+const bindings_1 = require("./bindings");
+const transform_1 = require("./transform");
+const migrate = (sources, wrappers = []) => {
+    const kinds = (0, bindings_1.resolveKinds)(sources, wrappers);
+    const outputs = new Map();
+    const reports = new Map();
+    const forwarders = new Set();
+    let unhandled = 0;
+    for (const [file, source] of sources) {
+        const { output, report } = (0, transform_1.transform)(source, { kinds: kinds.get(file) });
+        outputs.set(file, output);
+        reports.set(file, report);
+        report.forwarders.forEach((f) => forwarders.add(f));
+        unhandled += report.unhandled.length;
+    }
+    return { outputs, reports, forwarders: [...forwarders].sort(), unhandled };
+};
+exports.migrate = migrate;

package/dist/cjs/v3/codemod/package.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACKAGE = void 0;
+/** The package the codemod rewrites imports and selectors of. */
+exports.PACKAGE = "@nolwenture/formik-jsonschema-form";

package/dist/cjs/v3/codemod/slots.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewriteSlots = exports.SLOT_NOTE = void 0;
+const bindings_1 = require("./bindings");
+exports.SLOT_NOTE = "/* fjsf-v3-codemod: slots get the library component as `Default`; a wrapper that rendered the 2.x component renders <props.Default {...props} /> */";
+const lineAt = (source, index) => source.slice(0, index).split("\n").length;
+const rewriteSlots = (source, report, kinds) => {
+    report.forwarders.push(...[...kinds].filter(([, k]) => k === "forwarder").map(([n]) => n).filter((n) => !report.forwarders.includes(n)));
+    let out = "";
+    let i = 0;
+    for (const site of (0, bindings_1.componentsSites)(source)) {
+        const where = { element: site.element, line: lineAt(source, site.attr) };
+        const kind = kinds.get(site.element);
+        if (kind === "library") {
+            report.slots++;
+            // `components=` sits at site.attr + 1 (after the whitespace the attribute pattern starts with)
+            out += source.slice(i, site.attr + 1) + `${exports.SLOT_NOTE} slots=`;
+            i = site.attr + 1 + "components=".length;
+        }
+        else if (kind === "forwarder")
+            report.kept.push(where);
+        else
+            report.unhandled.push(where);
+    }
+    return out + source.slice(i);
+};
+exports.rewriteSlots = rewriteSlots;

package/dist/cjs/v3/codemod/transform.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = exports.stylesFormView = exports.PACKAGE = void 0;
+// The pro3 codemod (S7, §4.3 (2), §7.5 step 3): one source file in, the rewritten file and a report out.
+// - `${FormComponents.X}` -> `.fjsf-X` (one class: specificity unchanged). The inert uses are listed and
+//   stay inert (Q7 I-1 + F-1): an override-only name is left as is (it interpolates nothing, as in 2.x), and
+//   in a FormView styling file the Form class cannot match the FormView's `fjsf-view-*` elements.
+// - `components=` -> `slots=` where it reaches the library (slots.ts), every other site reported.
+// - deep `dist/types/*` imports -> the package root; `FieldInfoProps` -> `import type`.
+// `styled(FormComponents.X)`, `registry.components` and `<FormComponents.X>` keep working (CM-a): unchanged.
+const styles_1 = require("../raw/styles");
+const componentTable_1 = require("../raw/model/form/componentTable");
+const package_1 = require("./package");
+const bindings_1 = require("./bindings");
+const slots_1 = require("./slots");
+var package_2 = require("./package");
+Object.defineProperty(exports, "PACKAGE", { enumerable: true, get: function () { return package_2.PACKAGE; } });
+/** The FormView names pro3 selects that a FormView renders (the shared MultipleChoice components). */
+const SHARED_WITH_VIEW = new Set(["MultipleChoiceFieldContainer", "MultipleChoiceFieldLabel"]);
+const lineAt = (source, index) => source.slice(0, index).split("\n").length;
+/** A file that styles the library's FormView (pro3's FormView/styledComponents.tsx): imports FormView, not Form. */
+const stylesFormView = (source) => {
+    const names = [...source.matchAll(new RegExp(`import\\s*\\{([^}]*)\\}\\s*from\\s*["']${package_1.PACKAGE}["']`, "g"))].flatMap((m) => m[1].split(",").map((s) => s.trim()));
+    return names.includes("FormView") && !names.includes("Form");
+};
+exports.stylesFormView = stylesFormView;
+const rewriteSelectors = (source, report, view) => source.replace(/\$\{\s*FormComponents\.(\w+)\s*\}/g, (match, name, index) => {
+    const line = lineAt(source, index);
+    const f1 = view && !SHARED_WITH_VIEW.has(name);
+    if (componentTable_1.FORM_COMPONENTS[name] === null) {
+        report.inert.push({ name, line, reasons: f1 ? ["I-1", "F-1"] : ["I-1"] });
+        return match; // undefined in 2.x and v3: interpolates nothing, as before
+    }
+    const cls = styles_1.fjsfClassNames[name];
+    if (!cls) {
+        report.unknown.push(`${name} (line ${line})`);
+        return match;
+    }
+    if (f1)
+        report.inert.push({ name, line, reasons: ["F-1"] });
+    report.selectors++;
+    return `.${cls}`;
+});
+/** Deep `dist/types/*` imports -> root; `FieldInfoProps` as `import type`. */
+const rewriteImports = (source, report) => source.replace(new RegExp(`import\\s+(type\\s+)?\\{([^}]*)\\}\\s*from\\s*["']${package_1.PACKAGE}/dist/types[^"']*["'];?`, "g"), (_m, typeOnly, list) => {
+    report.imports++;
+    const names = list.split(",").map((s) => s.trim()).filter(Boolean);
+    const types = typeOnly ? names : names.filter((n) => n === "FieldInfoProps");
+    const values = typeOnly ? [] : names.filter((n) => n !== "FieldInfoProps");
+    return [
+        values.length ? `import { ${values.join(", ")} } from "${package_1.PACKAGE}";` : "",
+        types.length ? `import type { ${types.join(", ")} } from "${package_1.PACKAGE}";` : "",
+    ].filter(Boolean).join("\n");
+});
+const transform = (source, options = {}) => {
+    const kinds = options.kinds ?? (0, bindings_1.localKinds)(source, new Map((options.wrappers ?? []).map((w) => [w, "library"])));
+    const report = { selectors: 0, inert: [], unknown: [], slots: 0, kept: [], unhandled: [], forwarders: [], imports: 0 };
+    const output = rewriteImports((0, slots_1.rewriteSlots)(rewriteSelectors(source, report, (0, exports.stylesFormView)(source)), report, kinds), report);
+    return { output, report };
+};
+exports.transform = transform;

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromDocument = void 0;
+const issues_1 = require("../raw/core/issues");
+const json_1 = require("../raw/core/json");
+const FILE_UPLOAD_VIEWS = ["todo", "hide"];
+const EMPTY_SCHEMA = () => ({ type: "object", properties: {} });
+const fromDocument = (input, sink = issues_1.ignoreIssues) => {
+    const invalid = (path) => sink((0, issues_1.issue)("DOCUMENT_INVALID", path || undefined));
+    const doc = (0, json_1.isPlainObject)(input) ? input : undefined;
+    if (!doc) {
+        invalid("");
+        return { schema: EMPTY_SCHEMA(), uiSchema: {}, values: undefined, options: {} };
+    }
+    let schema = doc.schema;
+    if (!(0, json_1.isPlainObject)(schema)) {
+        invalid("schema");
+        schema = EMPTY_SCHEMA();
+    }
+    let uiSchema = doc.uiSchema;
+    if (uiSchema === undefined)
+        uiSchema = {};
+    else if (!(0, json_1.isPlainObject)(uiSchema)) {
+        invalid("uiSchema");
+        uiSchema = {};
+    }
+    const options = {};
+    if (doc.formLocalization !== undefined) {
+        if ((0, json_1.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 !== issues_1.ignoreIssues)
+        options.sink = sink;
+    return { schema, uiSchema, values: doc.data, options };
+};
+exports.fromDocument = fromDocument;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDocumentToString = exports.fromDocument = void 0;
+// @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.
+var fromDocument_1 = require("./fromDocument");
+Object.defineProperty(exports, "fromDocument", { enumerable: true, get: function () { return fromDocument_1.fromDocument; } });
+var render_1 = require("./render");
+Object.defineProperty(exports, "renderDocumentToString", { enumerable: true, get: function () { return render_1.renderDocumentToString; } });

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDocumentToString = void 0;
+const issues_1 = require("../raw/core/issues");
+const view_1 = require("../raw/model/view");
+const fromDocument_1 = require("./fromDocument");
+/** CSS text that cannot close the <style> element it is put in. */
+const safeCss = (css) => css.replace(/<\/(style)/gi, "<\\/$1");
+const renderDocumentToString = (input, options = {}) => {
+    const sink = options.sink ?? issues_1.ignoreIssues;
+    const { schema, uiSchema, values, options: view } = (0, fromDocument_1.fromDocument)(input, sink);
+    const html = (0, view_1.renderViewToString)(schema, uiSchema, values, view);
+    let css = "";
+    try {
+        css = typeof options.styles === "function" ? options.styles() : options.styles ?? "";
+    }
+    catch {
+        sink((0, issues_1.issue)("DOCUMENT_INVALID", "styles"));
+    }
+    return typeof css === "string" && css ? `<style>${safeCss(css)}</style>${html}` : html;
+};
+exports.renderDocumentToString = renderDocumentToString;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setTitleValues = exports.immutablySwapItems = exports.getSelectedEnum = exports.getEnums = exports.EnumsTypes = exports.orderByUiSchema = exports.orderAdditionalProperties = exports.getTitle = exports.getHiddenProperties = exports.getDescription = exports.extractUiSchema = exports.resolveSchema = exports.resolveOneOfValue = exports.deepOverlap = exports.mergeSchemas = exports.solveReferences = exports.hasReferences = exports.createValidationSchema = exports.createInitialValues = exports.guessType = exports.getSchemaType = exports.getDefaultValueForType = exports.isObject = void 0;
+// 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.
+const schemaType_1 = require("../core/schemaType");
+Object.defineProperty(exports, "getSchemaType", { enumerable: true, get: function () { return schemaType_1.getSchemaType; } });
+Object.defineProperty(exports, "guessType", { enumerable: true, get: function () { return schemaType_1.guessType; } });
+const isObject = (object) => object != null && typeof object === "object";
+exports.isObject = isObject;
+exports.getDefaultValueForType = schemaType_1.defaultValueForType;
+var initialValues_1 = require("../core/initialValues");
+Object.defineProperty(exports, "createInitialValues", { enumerable: true, get: function () { return initialValues_1.createInitialValues; } });
+var validation_1 = require("../validation");
+Object.defineProperty(exports, "createValidationSchema", { enumerable: true, get: function () { return validation_1.createValidationSchema; } });
+var refs_1 = require("../core/refs");
+Object.defineProperty(exports, "hasReferences", { enumerable: true, get: function () { return refs_1.hasReferences; } });
+Object.defineProperty(exports, "solveReferences", { enumerable: true, get: function () { return refs_1.solveReferences; } });
+var merge_1 = require("../core/merge");
+Object.defineProperty(exports, "mergeSchemas", { enumerable: true, get: function () { return merge_1.mergeSchemas; } });
+var conditionals_1 = require("../core/conditionals");
+Object.defineProperty(exports, "deepOverlap", { enumerable: true, get: function () { return conditionals_1.deepOverlap; } });
+Object.defineProperty(exports, "resolveOneOfValue", { enumerable: true, get: function () { return conditionals_1.resolveOneOfValue; } });
+Object.defineProperty(exports, "resolveSchema", { enumerable: true, get: function () { return conditionals_1.resolveSchema; } });
+var uiSchema_1 = require("../core/uiSchema");
+Object.defineProperty(exports, "extractUiSchema", { enumerable: true, get: function () { return uiSchema_1.extractUiSchema; } });
+Object.defineProperty(exports, "getDescription", { enumerable: true, get: function () { return uiSchema_1.getDescription; } });
+Object.defineProperty(exports, "getHiddenProperties", { enumerable: true, get: function () { return uiSchema_1.getHiddenProperties; } });
+Object.defineProperty(exports, "getTitle", { enumerable: true, get: function () { return uiSchema_1.getTitle; } });
+Object.defineProperty(exports, "orderAdditionalProperties", { enumerable: true, get: function () { return uiSchema_1.orderAdditionalProperties; } });
+Object.defineProperty(exports, "orderByUiSchema", { enumerable: true, get: function () { return uiSchema_1.orderByUiSchema; } });
+var enums_1 = require("../core/enums");
+Object.defineProperty(exports, "EnumsTypes", { enumerable: true, get: function () { return enums_1.EnumsTypes; } });
+Object.defineProperty(exports, "getEnums", { enumerable: true, get: function () { return enums_1.getEnums; } });
+Object.defineProperty(exports, "getSelectedEnum", { enumerable: true, get: function () { return enums_1.getSelectedEnum; } });
+var titles_1 = require("../core/titles");
+Object.defineProperty(exports, "immutablySwapItems", { enumerable: true, get: function () { return titles_1.immutablySwapItems; } });
+Object.defineProperty(exports, "setTitleValues", { enumerable: true, get: function () { return titles_1.setTitleValues; } });

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.itemSchema = exports.valueTypeMismatch = exports.normalizeArraySchema = void 0;
+const json_1 = require("./json");
+const issues_1 = require("./issues");
+const schemaType_1 = require("./schemaType");
+const asSchema = (value) => {
+    if (value === true)
+        return {};
+    return (0, json_1.isPlainObject)(value) ? value : undefined;
+};
+const normalizeArraySchema = (schema, sink = issues_1.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((0, issues_1.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 };
+};
+exports.normalizeArraySchema = normalizeArraySchema;
+/** True when a stored value's JSON type cannot be an instance of the schema's type. */
+const valueTypeMismatch = (value, schema) => {
+    if (value === undefined || !schema)
+        return false;
+    const { type, nullable } = (0, schemaType_1.normaliseType)(schema);
+    const actual = (0, json_1.jsonTypeOf)(value);
+    if (type === "any")
+        return false;
+    if (actual === "null")
+        return !(nullable || type === "null");
+    if (type === "integer")
+        return actual !== "number";
+    return actual !== type;
+};
+exports.valueTypeMismatch = valueTypeMismatch;
+/** Schema used for item `index`, given the stored value of that item. */
+const itemSchema = (norm, index, value) => {
+    if (index < norm.fixed.length)
+        return { schema: norm.fixed[index], guarded: false, fixed: true };
+    if (index === 0 && norm.placeholder && (0, exports.valueTypeMismatch)(value, norm.tail)) {
+        return { schema: norm.placeholder, guarded: true, fixed: false };
+    }
+    return { schema: norm.tail, guarded: false, fixed: false };
+};
+exports.itemSchema = itemSchema;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.choiceStyle = void 0;
+// 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. */
+const choiceStyle = (style) => typeof style === "string" && Object.prototype.hasOwnProperty.call(STYLES, style) ? { style: STYLES[style] } : {};
+exports.choiceStyle = choiceStyle;