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

package/dist/cjs/v3/raw/dom/elements.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineFjsfElements = void 0;
+const controller_1 = require("./controller");
+const EVENTS = ["change", "blur", "submit", "structure", "order", "validate", "error"];
+const ATTRIBUTES = { schema: "schema", "ui-schema": "uiSchema", values: "values" };
+const parse = (text) => {
+    if (text === null)
+        return { ok: true, value: undefined };
+    try {
+        return { ok: true, value: JSON.parse(text) };
+    }
+    catch {
+        return { ok: false }; // invalid JSON: the previous value stays
+    }
+};
+const elementClass = (Base, mode) => class FjsfForm extends Base {
+    static observedAttributes = Object.keys(ATTRIBUTES);
+    state = { options: {} };
+    ctl;
+    get controller() {
+        return this.ctl;
+    }
+    get schema() {
+        return this.state.schema;
+    }
+    set schema(schema) {
+        this.set({ schema });
+    }
+    get uiSchema() {
+        return this.state.uiSchema;
+    }
+    set uiSchema(uiSchema) {
+        this.set({ uiSchema });
+    }
+    /** The current values (the controller's while mounted). */
+    get values() {
+        return this.ctl ? this.ctl.getState().values : this.state.values;
+    }
+    set values(values) {
+        this.set({ values });
+    }
+    get options() {
+        return this.state.options;
+    }
+    set options(options) {
+        this.set({ options: options ?? {} });
+    }
+    attributeChangedCallback(name, _old, text) {
+        const parsed = parse(text);
+        if (parsed.ok && ATTRIBUTES[name])
+            this.set({ [ATTRIBUTES[name]]: parsed.value });
+    }
+    connectedCallback() {
+        if (this.ctl || this.state.schema === undefined)
+            return;
+        const ctl = new controller_1.FormController({ schema: this.state.schema, uiSchema: this.state.uiSchema, values: this.state.values, options: { ...this.state.options, mode } });
+        for (const type of EVENTS)
+            ctl.on(type, (detail) => this.dispatchEvent(new CustomEvent(`fjsf-${type}`, { detail, bubbles: true })));
+        this.ctl = ctl;
+        ctl.mount(this);
+    }
+    disconnectedCallback() {
+        if (!this.ctl)
+            return;
+        this.state.values = this.ctl.getState().values; // a moved element keeps its values
+        this.ctl.destroy();
+        this.ctl = undefined;
+    }
+    set(patch) {
+        this.state = { ...this.state, ...patch };
+        if (this.ctl)
+            this.ctl.update({ ...patch, ...(patch.options ? { options: { ...patch.options, mode } } : {}) });
+        else if (this.isConnected)
+            this.connectedCallback();
+    }
+};
+/** Registers <fjsf-form> and <fjsf-form-view> (each once) in `registry`; without one (server-side) it does nothing. */
+const defineFjsfElements = (registry = globalThis.customElements) => {
+    const Base = globalThis.HTMLElement;
+    if (!registry || !Base)
+        return;
+    if (!registry.get("fjsf-form"))
+        registry.define("fjsf-form", elementClass(Base, "form"));
+    if (!registry.get("fjsf-form-view"))
+        registry.define("fjsf-form-view", elementClass(Base, "view"));
+};
+exports.defineFjsfElements = defineFjsfElements;

package/dist/cjs/v3/raw/dom/emitter.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmitter = void 0;
+const createEmitter = () => {
+    const handlers = new Map();
+    // once(): the handler's wrapper per type, so off(type, handler) also cancels a pending once
+    const wrappers = new Map();
+    const on = (type, handler) => {
+        if (!handlers.has(type))
+            handlers.set(type, new Set());
+        handlers.get(type).add(handler);
+        return () => off(type, handler);
+    };
+    const off = (type, handler) => {
+        handlers.get(type)?.delete(handler);
+        const wrapper = wrappers.get(type)?.get(handler);
+        if (wrapper) {
+            wrappers.get(type).delete(handler);
+            handlers.get(type)?.delete(wrapper);
+        }
+    };
+    const once = (type, handler) => {
+        const wrapper = (event) => {
+            off(type, handler);
+            handler(event);
+        };
+        if (!wrappers.has(type))
+            wrappers.set(type, new Map());
+        wrappers.get(type).set(handler, wrapper);
+        on(type, wrapper);
+        return () => off(type, handler);
+    };
+    const emit = (event) => {
+        for (const handler of [...(handlers.get(event.type) ?? [])]) {
+            try {
+                handler(event);
+            }
+            catch (error) {
+                // reported, not rethrown: a consumer's handler cannot stop the form
+                globalThis.console?.error?.("fjsf: event handler failed", error);
+            }
+        }
+    };
+    const clear = () => (handlers.clear(), wrappers.clear());
+    return { on, off, once, emit, clear };
+};
+exports.createEmitter = createEmitter;

package/dist/cjs/v3/raw/dom/nodes.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vnodeOf = exports.isDomNode = void 0;
+const vnode_1 = require("../model/vnode");
+const SKIP = new Set(["script", "style", "iframe", "object", "embed", "template"]);
+const isDomNode = (value) => typeof value === "object" && value !== null && typeof value.nodeType === "number" && typeof value.cloneNode === "function";
+exports.isDomNode = isDomNode;
+const vnodeOf = (node, depth = 0) => {
+    if (depth > 64)
+        return null;
+    if (node.nodeType === 3)
+        return node.data;
+    if (node.nodeType === 11)
+        return (0, vnode_1.h)("#fragment", {}, [...node.childNodes].map((c) => (0, exports.vnodeOf)(c, depth + 1)));
+    if (node.nodeType !== 1)
+        return null;
+    const el = node;
+    const tag = el.localName;
+    if (SKIP.has(tag))
+        return null;
+    // no script URLs either: the host's markup is drawn like library markup
+    const attrs = Object.fromEntries([...el.attributes].filter((a) => !/^\s*javascript:/i.test(a.value)).map((a) => [a.name, a.value]));
+    return (0, vnode_1.h)(tag, attrs, [...el.childNodes].map((c) => (0, exports.vnodeOf)(c, depth + 1)));
+};
+exports.vnodeOf = vnodeOf;

package/dist/cjs/v3/raw/dom/render.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCore = void 0;
+const paths_1 = require("../core/paths");
+const form_1 = require("../model/form");
+const toDOM_1 = require("../serialize/toDOM");
+const build_1 = require("./build");
+const delegate_1 = require("./delegate");
+const nodes_1 = require("./nodes");
+const UPLOADS = new Set(["FileUploadField", "FilesUploadField"]);
+/** An upload field's markup in its current upload state (the React host renders its upload component there). */
+const uploadHost = (core, ctx, host) => {
+    const p = host.props;
+    return core.uploads.markup(ctx, host.field, {
+        name: String(p.name ?? ""),
+        schema: p.schema,
+        ui: p.uiSchema,
+        ...(p.required !== undefined ? { required: !!p.required } : {}),
+        ...(p["data-fjsf-hidden"] ? { hidden: true } : {}),
+    });
+};
+const report = (core, issues) => {
+    for (const issue of issues) {
+        const key = JSON.stringify(issue);
+        if (core.reported.has(key))
+            continue;
+        core.reported.add(key);
+        core.emit({ type: "error", ...issue });
+    }
+};
+const fillSlot = (core, el, renderer, node, controller) => {
+    const name = String(node.attrs["data-fjsf-slot"] ?? "");
+    const p = core.slotProps.get(name) ?? {};
+    const field = { name, schema: p.schema, uiSchema: p.uiSchema, ...(p.required !== undefined ? { required: !!p.required } : {}), value: (0, paths_1.getIn)(core.store.getState().values, name) };
+    try {
+        renderer(el, field, controller);
+    }
+    catch (error) {
+        globalThis.console?.error?.("fjsf: a slot renderer failed", error);
+    }
+};
+const settleAppearances = (core, appeared, prune, guesses) => {
+    const removed = [...core.seen].filter((path) => !appeared.some((a) => a.path === path));
+    const fresh = (0, form_1.newAppearances)(appeared, core.seen);
+    if (Object.keys(guesses).length)
+        core.ui = { ...core.ui, anyTypes: { ...guesses, ...core.ui.anyTypes } };
+    const values = core.store.getState().values;
+    const next = fresh.length || prune.length ? (0, form_1.settle)(values, fresh, prune) : values;
+    const prunedValues = prune.flatMap(({ path, keys }) => {
+        const object = path ? (0, paths_1.getIn)(values, path) : values;
+        return keys.filter((k) => object && typeof object === "object" && k in object).map((k) => (path ? `${path}.${k}` : k));
+    });
+    if (next !== values) {
+        core.act(() => core.store.setValues(next));
+        for (const a of fresh) {
+            const value = (0, paths_1.getIn)(next, a.path);
+            if (value !== (0, paths_1.getIn)(values, a.path))
+                core.emit({ type: "change", path: a.path, value, values: next, cause: "default" });
+        }
+        for (const { path } of prune) {
+            const value = path ? (0, paths_1.getIn)(next, path) : next;
+            if (value !== (path ? (0, paths_1.getIn)(values, path) : values))
+                core.emit({ type: "change", path, value, values: next, cause: "prune" });
+        }
+    }
+    if (fresh.length || removed.length || prunedValues.length)
+        core.emit({ type: "structure", added: fresh.map((a) => a.path), removed, prunedValues });
+};
+const renderCore = (core, controller) => {
+    const target = core.target;
+    if (!target)
+        return;
+    const issues = [];
+    let built;
+    try {
+        built = (0, build_1.buildTree)(core.schema, core.uiSchema, core.store.getState(), core.ui, core.options, (i) => issues.push(i));
+    }
+    catch (error) {
+        // never-throw: the builder reports problems as codes; anything else keeps the last drawn form
+        globalThis.console?.error?.("fjsf: render failed", error);
+        return;
+    }
+    core.tree = built.tree;
+    core.keyActions.clear();
+    core.slotProps.clear();
+    const slots = [];
+    (0, toDOM_1.toDOM)(target, built.tree, {
+        doc: target.ownerDocument,
+        on: core.records,
+        host: (node) => {
+            const host = node.host;
+            if (host?.kind === "value")
+                return (0, nodes_1.isDomNode)(host.value) ? [(0, nodes_1.vnodeOf)(host.value)] : undefined;
+            if (host?.kind === "field" && host.field && !UPLOADS.has(host.field))
+                core.slotProps.set(String(host.props.name ?? ""), host.props);
+            return host?.kind === "field" && built.ctx && UPLOADS.has(host.field) && !core.options.fields?.[host.field] ? [uploadHost(core, built.ctx, host)] : undefined;
+        },
+        drawn: (el, node) => {
+            const on = node.on;
+            if (on?.change && (0, delegate_1.isTextControl)(el))
+                core.tracked.set(el, el.value);
+            const key = on?.documentKeydown;
+            if (key?.open)
+                core.keyActions.set(key.path, { action: key, el });
+            if (key && (!key.open || (core.ui.active?.[key.path] ?? -1) < 0))
+                core.scrolled.delete(key.path);
+            if (on?.active && core.scrolled.get(on.active.path) !== on.active.index) {
+                core.scrolled.set(on.active.path, on.active.index);
+                el.scrollIntoView?.({ behavior: "auto", block: "center", inline: "center" });
+            }
+            const renderer = node.attrs["data-fjsf-slot"] !== undefined ? core.options.fields?.[String(node.attrs["data-fjsf-field"])] : undefined;
+            if (renderer)
+                slots.push([el, renderer, node]);
+        },
+    });
+    report(core, issues);
+    for (const [el, renderer, node] of slots)
+        fillSlot(core, el, renderer, node, controller);
+    if (built.ctx)
+        settleAppearances(core, built.ctx.appeared, built.ctx.prune, built.ctx.anyGuesses);
+};
+exports.renderCore = renderCore;

package/dist/cjs/v3/raw/dom/upload.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUploads = void 0;
+const paths_1 = require("../core/paths");
+const upload_1 = require("../model/form/upload");
+const LOCAL = new Set(["filePick", "fileChosen", "fileRemove", "filesChosen", "filesRemove", "filesDrag", "filesDrop"]);
+/** The upload markup with each upload action naming its field (the React host kept them in a closure). */
+const tagged = (node, field) => {
+    if (!node || typeof node !== "object")
+        return node;
+    const on = node.on && Object.fromEntries(Object.entries(node.on).map(([k, a]) => [k, LOCAL.has(a?.type) ? { ...a, field } : a]));
+    return { ...node, ...(on ? { on } : {}), children: node.children.map((c) => tagged(c, field)) };
+};
+const reject = (what) => () => {
+    globalThis.console?.error?.(`Lacking ${what}`);
+    return Promise.reject();
+};
+const accepted = (file, types) => {
+    const list = Array.isArray(types) ? types : typeof types === "string" ? types.split(",").map((t) => t.trim()).filter(Boolean) : [];
+    return !list.length || list.some((t) => (t.endsWith("/*") ? file.type.startsWith(t.slice(0, -2)) : t === file.type));
+};
+const stop = (e) => (e.preventDefault(), e.stopPropagation());
+const createUploads = (host) => {
+    const singles = new Map();
+    const multis = new Map();
+    const file = () => ({ uploadFile: reject("upload from FileUploadContext"), fetchFile: (v) => Promise.resolve(v), removeFile: reject("remove from FileUploadContext"), ...host.uploads()?.file });
+    const files = () => ({ uploadFiles: reject("upload from FilesUploadContext"), removeFile: reject("remove from FileUploadContext"), ...host.uploads()?.files });
+    let alive = true;
+    const later = (fn) => () => alive && (fn(), host.rerender());
+    const single = (path, value) => {
+        const s = singles.get(path) ?? { uploadedFile: null, progress: 0 };
+        singles.set(path, s);
+        if (!s.fetched || s.fetched.value !== value) {
+            const fetched = (s.fetched = { value });
+            Promise.resolve()
+                .then(() => file().fetchFile(value))
+                .then((f) => later(() => s.fetched === fetched && (s.uploadedFile = f ?? null))(), () => later(() => s.fetched === fetched && (s.uploadedFile = null))());
+        }
+        return s;
+    };
+    const multi = (path, stored) => {
+        const m = multis.get(path) ?? { stored: {}, files: [], progress: {}, dragging: false, depth: 0 };
+        multis.set(path, m);
+        if (m.stored !== stored) {
+            m.stored = stored;
+            const value = stored ?? [];
+            if (Array.isArray(value)) {
+                m.files = (0, upload_1.filesOf)(value);
+                m.files.forEach((f) => (m.progress = { ...m.progress, [f.progressId]: 100 }));
+            }
+        }
+        return m;
+    };
+    /** The markup of an upload field in its current state. */
+    const markup = (ctx, field, p) => {
+        const stored = (0, paths_1.getIn)(ctx.values, p.name);
+        const readOnly = p.schema?.readOnly === true;
+        if (field === "FileUploadField") {
+            const s = Object.assign(single(p.name, stored), { readOnly });
+            return tagged((0, upload_1.fileUploadMarkup)(ctx, p, { value: stored, uploadedFile: s.uploadedFile, progress: s.progress }), p.name);
+        }
+        const m = Object.assign(multi(p.name, stored), { readOnly, ip: p.ui?.["ui:props"] ?? p.ui?.props ?? {} });
+        return tagged((0, upload_1.filesUploadMarkup)(ctx, p, { value: stored ?? [], files: m.files, progress: m.progress, dragging: m.dragging }), p.name);
+    };
+    const uploadOne = async (path, chosen) => {
+        const s = singles.get(path);
+        const data = new globalThis.FormData();
+        data.append("file", chosen);
+        try {
+            let fake = 0;
+            clearInterval(s.timer);
+            s.timer = setInterval(later(() => ((fake += 10) <= 100 ? (s.progress = fake) : clearInterval(s.timer))), 100);
+            const result = await file().uploadFile({ data, onUploadProgress: (e) => e.total != null && Math.round((e.loaded * 100) / e.total) === 100 && later(() => (s.progress = 100))() });
+            if (alive)
+                host.setValue(path, result);
+        }
+        catch (error) {
+            globalThis.console?.error?.("File upload failed", error);
+        }
+    };
+    const uploadMany = async (path, list) => {
+        const m = multis.get(path);
+        const value = (0, paths_1.getIn)(host.values(), path) ?? [];
+        const withIds = list.map((data) => ({ data, progressId: data.name + data.size + data.lastModified + Math.random() }));
+        m.files = m.files.concat(withIds.map(({ data, progressId }) => ({ name: data.name, size: data.size, progressId, mimeType: data.type, id: null })));
+        host.rerender();
+        try {
+            const result = await files().uploadFiles({ files: withIds, onUploadProgress: (e, id) => e.total != null && later(() => (m.progress = { ...m.progress, [id]: Math.round((e.loaded * 100) / e.total) }))() });
+            if (!alive)
+                return;
+            m.files = m.files.map((item) => ({ ...item, id: result.find((r) => r.progressId === item.progressId)?.id ?? item.id }));
+            host.setValue(path, (Array.isArray(value) ? value : []).concat(result.map(({ progressId: _p, ...rest }) => rest)));
+        }
+        catch (error) {
+            globalThis.console?.error?.("File upload failed", error);
+        }
+    };
+    /** Handles an upload action; false when the action is not an upload one. */
+    const handle = (action, event, el) => {
+        if (!LOCAL.has(action?.type) || typeof action.field !== "string")
+            return false;
+        const path = action.field;
+        const m = multis.get(path);
+        switch (action.type) {
+            case "filePick":
+                if (!action.locked)
+                    host.pick(action.id);
+                break;
+            case "fileChosen": {
+                const chosen = el.files?.[0];
+                if (chosen) {
+                    void uploadOne(path, chosen);
+                    el.value = "";
+                }
+                break;
+            }
+            case "fileRemove": {
+                const s = singles.get(path);
+                if (s?.uploadedFile?.name && !s.readOnly) {
+                    void Promise.resolve(file().removeFile(String(s.uploadedFile.name))).then(later(() => ((s.progress = 0), host.setValue(path, null))), () => undefined);
+                }
+                break;
+            }
+            case "filesChosen": {
+                const list = el.files;
+                if (list)
+                    void uploadMany(path, [...list]);
+                break;
+            }
+            case "filesRemove": {
+                const f = m?.files.find((x) => x.progressId === action.progressId);
+                if (!m || !f?.id)
+                    break;
+                const value = (0, paths_1.getIn)(host.values(), path) ?? [];
+                void Promise.resolve(files().removeFile(f)).then(later(() => {
+                    const { [f.progressId]: _gone, ...rest } = m.progress;
+                    m.progress = rest;
+                    m.files = m.files.filter((x) => x.id !== f.id);
+                    host.setValue(path, (Array.isArray(value) ? value : []).filter((x) => x?.id !== f.id));
+                }), () => undefined);
+                break;
+            }
+            case "filesDrag":
+                if (!m || m.readOnly)
+                    break;
+                stop(event);
+                if (action.enter === true) {
+                    m.depth++;
+                    if (event.dataTransfer?.items?.length)
+                        later(() => (m.dragging = true))();
+                }
+                else if (action.enter === false && --m.depth === 0)
+                    later(() => (m.dragging = false))();
+                break;
+            case "filesDrop": {
+                if (!m || m.readOnly)
+                    break;
+                stop(event);
+                m.dragging = false;
+                m.depth = 0;
+                const transfer = event.dataTransfer;
+                let dropped = [...(transfer?.files ?? [])];
+                const ip = m.ip ?? {};
+                const multiple = ip.allowMultipleFiles ?? true;
+                if (!multiple && m.files.length > 0)
+                    dropped = [];
+                else if (!multiple)
+                    dropped = dropped.slice(0, 1);
+                dropped = dropped.filter((f) => accepted(f, ip.acceptedFiletypes));
+                if (dropped.length)
+                    void uploadMany(path, dropped);
+                else
+                    host.rerender();
+                transfer?.clearData?.();
+                break;
+            }
+        }
+        return true;
+    };
+    const destroy = () => {
+        alive = false;
+        singles.forEach((s) => clearInterval(s.timer));
+    };
+    return { markup, handle, destroy };
+};
+exports.createUploads = createUploads;

package/dist/cjs/v3/raw/i18n/en.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.en = void 0;
+// `fjsf` namespace, English. Default locale: every string equals the 2.x literal
+// (createValidationSchema.ts:10-26, Form.tsx "Send", ObjectField "Give key", ...),
+// so consumers see no change unless they pick another locale (I18N-b, §2.12).
+exports.en = {
+    "validation.error.required": "Required",
+    "validation.error.minLength": "Must be at least {limit} characters",
+    "validation.error.maxLength": "Must be at most {limit} characters",
+    "validation.error.pattern": "Invalid format",
+    "validation.error.minimum": "Must be at least {min}",
+    "validation.error.maximum": "Must be at most {max}",
+    "validation.error.exclusiveMinimum": "Must be more than {min}",
+    "validation.error.exclusiveMaximum": "Must be less than {max}",
+    "validation.error.multipleOf": "Must be a multiple of {multipleOf}",
+    "validation.error.minItems": "Must have at least {min} items",
+    "validation.error.maxItems": "Must have at most {max} items",
+    "validation.error.uniqueItems": "Items must be unique",
+    "validation.error.enum": "Invalid value",
+    "validation.error.const": "Invalid value",
+    "validation.error.notConst": "Invalid value",
+    "form.submit": "Send",
+    "form.additionalProperty.prompt": "Give key",
+    "view.boolean.selected": "Selected",
+    "view.boolean.notSelected": "Not selected",
+    "field.date.picker": "Date picker",
+    "field.unsupported": "!!! Unsupported field \"{name}\" !!!",
+    "code.SCHEMA_UNSUPPORTED_TYPE": "Unsupported field type",
+    "code.SCHEMA_MISSING_TYPE": "Field has no type",
+    "code.SCHEMA_ARRAY_AMBIGUOUS": "Array item schema is ambiguous",
+    "code.SCHEMA_ENUM_CONFLICT": "More than one of enum, oneOf and anyOf; enum wins, then oneOf",
+    "code.REF_UNSUPPORTED": "Unsupported reference",
+    "code.REF_NOT_FOUND": "Reference not found",
+    "code.REF_CYCLE": "Circular reference",
+    "code.REF_DEPTH_EXCEEDED": "Reference nesting is too deep",
+    "code.PATTERN_INVALID": "Invalid pattern",
+    "code.PATTERN_REJECTED": "Unsafe pattern was ignored",
+    "code.PROP_REJECTED": "Property is not allowed",
+    "code.KEY_REJECTED": "Key is not allowed",
+    "code.KEY_AMBIGUOUS": "Key contains path characters",
+    "code.FIELD_UNKNOWN": "Unknown field",
+    "code.TEMPLATE_UNKNOWN": "Unknown template",
+    "code.TEMPLATE_DISABLED": "Template is disabled here",
+    "code.DOCUMENT_INVALID": "Document is not valid: the schema or a part of it was replaced",
+    "code.SANITIZER_UNAVAILABLE": "HTML sanitiser is unavailable",
+};

package/dist/cjs/v3/raw/i18n/fi.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fi = void 0;
+exports.fi = {
+    "validation.error.required": "Pakollinen",
+    "validation.error.minLength": "Vähintään {limit} merkkiä",
+    "validation.error.maxLength": "Enintään {limit} merkkiä",
+    "validation.error.pattern": "Virheellinen muoto",
+    "validation.error.minimum": "Vähintään {min}",
+    "validation.error.maximum": "Enintään {max}",
+    "validation.error.exclusiveMinimum": "Oltava suurempi kuin {min}",
+    "validation.error.exclusiveMaximum": "Oltava pienempi kuin {max}",
+    "validation.error.multipleOf": "Oltava luvun {multipleOf} monikerta",
+    "validation.error.minItems": "Vähintään {min} kohdetta",
+    "validation.error.maxItems": "Enintään {max} kohdetta",
+    "validation.error.uniqueItems": "Kohteiden on oltava yksilöllisiä",
+    "validation.error.enum": "Virheellinen arvo",
+    "validation.error.const": "Virheellinen arvo",
+    "validation.error.notConst": "Virheellinen arvo",
+    "form.submit": "Lähetä",
+    "form.additionalProperty.prompt": "Anna avain",
+    "view.boolean.selected": "Valittu",
+    "view.boolean.notSelected": "Ei valittu",
+    "field.date.picker": "Päivämäärän valitsin",
+    "field.unsupported": "!!! Kenttätyyppiä \"{name}\" ei tueta !!!",
+    "code.SCHEMA_UNSUPPORTED_TYPE": "Kenttätyyppiä ei tueta",
+    "code.SCHEMA_MISSING_TYPE": "Kentältä puuttuu tyyppi",
+    "code.SCHEMA_ARRAY_AMBIGUOUS": "Listan kohteen skeema on monitulkintainen",
+    "code.SCHEMA_ENUM_CONFLICT": "Useampi kuin yksi kentistä enum, oneOf ja anyOf; enum ensin, sitten oneOf",
+    "code.REF_UNSUPPORTED": "Viittausta ei tueta",
+    "code.REF_NOT_FOUND": "Viittausta ei löydy",
+    "code.REF_CYCLE": "Kehäviittaus",
+    "code.REF_DEPTH_EXCEEDED": "Viittaukset ovat liian syvällä",
+    "code.PATTERN_INVALID": "Virheellinen säännöllinen lauseke",
+    "code.PATTERN_REJECTED": "Vaarallinen säännöllinen lauseke ohitettiin",
+    "code.PROP_REJECTED": "Ominaisuus ei ole sallittu",
+    "code.KEY_REJECTED": "Avain ei ole sallittu",
+    "code.KEY_AMBIGUOUS": "Avain sisältää polkumerkkejä",
+    "code.FIELD_UNKNOWN": "Tuntematon kenttä",
+    "code.TEMPLATE_UNKNOWN": "Tuntematon pohja",
+    "code.TEMPLATE_DISABLED": "Pohja ei ole käytössä tässä",
+    "code.DOCUMENT_INVALID": "Asiakirja ei kelpaa: skeema tai sen osa korvattiin",
+    "code.SANITIZER_UNAVAILABLE": "HTML-puhdistin ei ole käytettävissä",
+};

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fi = exports.en = exports.createTranslator = exports.catalogs = void 0;
+const en_1 = require("./en");
+Object.defineProperty(exports, "en", { enumerable: true, get: function () { return en_1.en; } });
+const fi_1 = require("./fi");
+Object.defineProperty(exports, "fi", { enumerable: true, get: function () { return fi_1.fi; } });
+exports.catalogs = { en: en_1.en, fi: fi_1.fi };
+const interpolate = (text, params) => text.replace(/\{(\w+)\}/g, (match, name) => (params && name in params ? String(params[name]) : match));
+const createTranslator = (locale = "en", overrides = {}) => {
+    const catalog = { ...en_1.en, ...(exports.catalogs[locale] ?? en_1.en), ...overrides };
+    return (key, params) => interpolate(catalog[key] ?? key, params);
+};
+exports.createTranslator = createTranslator;