@luomus/laji-form 14.3.6

package/lib/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const LajiForm_1 = require("./components/LajiForm");
+const React = require("react");
+const react_dom_1 = require("react-dom");
+class LajiFormWrapper {
+    constructor(props) {
+        this.submit = () => {
+            this.lajiForm.submit();
+        };
+        this.submitOnlySchemaValidations = () => {
+            this.lajiForm.submitOnlySchemaValidations();
+        };
+        this.setState = (state) => {
+            this.state = Object.assign(Object.assign({}, this.state), state);
+            this.lajiForm = react_dom_1.render(React.createElement(LajiForm_1.default, Object.assign(Object.assign({}, this.props), this.state), null), this.rootElem);
+        };
+        this.pushBlockingLoader = () => {
+            this.lajiForm.pushBlockingLoader();
+        };
+        this.popBlockingLoader = () => {
+            this.lajiForm.popBlockingLoader();
+        };
+        this.getSettings = () => {
+            return this.lajiForm.getSettings();
+        };
+        this.destroy = () => {
+            this.lajiForm.destroy();
+            react_dom_1.unmountComponentAtNode(this.rootElem);
+        };
+        this.unmount = this.destroy;
+        const { rootElem } = props, _props = __rest(props, ["rootElem"]);
+        this.props = props;
+        this.rootElem = rootElem;
+        this.lajiForm = react_dom_1.render(React.createElement(LajiForm_1.default, _props, null), this.rootElem);
+        this.state = {};
+    }
+}
+exports.default = LajiFormWrapper;

package/lib/services/blocker-service.d.ts

@@ -0,0 +1,11 @@
+import { FormContext } from "../components/LajiForm";
+export default class BlockerService {
+    private formContext;
+    private blockingLoaderCounter;
+    private blockingLoaderRef;
+    constructor(formContext: FormContext);
+    initialize(): void;
+    destroy(): void;
+    push: () => void;
+    pop: () => void;
+}

package/lib/services/blocker-service.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BlockerService {
+    constructor(formContext) {
+        this.blockingLoaderCounter = 0;
+        this.push = () => {
+            this.blockingLoaderCounter++;
+            if (this.blockingLoaderCounter === 1) {
+                this.blockingLoaderRef.className = "laji-form blocking-loader entering";
+                this.formContext.services.keyHandler.block();
+            }
+        };
+        this.pop = () => {
+            this.blockingLoaderCounter--;
+            if (this.blockingLoaderCounter < 0) {
+                console.warn("laji-form: Blocking loader was popped before pushing!");
+            }
+            else if (this.blockingLoaderCounter === 0) {
+                this.blockingLoaderRef.className = "laji-form blocking-loader leave-start";
+                this.formContext.setTimeout(() => {
+                    if (this.blockingLoaderCounter > 0) {
+                        this.blockingLoaderRef.className = "laji-form blocking-loader entering";
+                        return;
+                    }
+                    if (this.blockingLoaderRef)
+                        this.blockingLoaderRef.className = "laji-form blocking-loader leaving";
+                    this.formContext.setTimeout(() => {
+                        if (!this.blockingLoaderRef) {
+                            return;
+                        }
+                        if (this.blockingLoaderCounter > 0) {
+                            this.blockingLoaderRef.className = "laji-form blocking-loader entering";
+                        }
+                        else {
+                            this.blockingLoaderRef.className = "laji-form blocking-loader";
+                        }
+                    }, 200); // should match css transition time.
+                });
+                this.formContext.services.keyHandler.unblock();
+            }
+        };
+        this.formContext = formContext;
+    }
+    initialize() {
+        this.blockingLoaderRef = document.createElement("div");
+        this.blockingLoaderRef.className = "laji-form blocking-loader";
+        if (this.blockingLoaderCounter > 0)
+            this.blockingLoaderRef.className = "laji-form blocking-loader entering";
+        document.body.appendChild(this.blockingLoaderRef);
+    }
+    destroy() {
+        document.body.removeChild(this.blockingLoaderRef);
+    }
+}
+exports.default = BlockerService;

package/lib/services/custom-event-service.d.ts

@@ -0,0 +1,17 @@
+declare type CustomEventListener = (data?: any, callback?: () => void) => boolean | void;
+/**
+ * A service for sending events outside DOM.
+ */
+export default class CustomEventService {
+    eventListeners: {
+        [eventName: string]: {
+            [id: string]: CustomEventListener[];
+        };
+    };
+    add(id: string, eventName: string, fn: CustomEventListener): void;
+    remove(id: string, eventName: string, fn: CustomEventListener): void;
+    send(id: string, eventName: string, data?: any, callback?: () => void, { bubble }?: {
+        bubble?: boolean | undefined;
+    }): void;
+}
+export {};

package/lib/services/custom-event-service.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A service for sending events outside DOM.
+ */
+class CustomEventService {
+    constructor() {
+        this.eventListeners = {};
+    }
+    add(id, eventName, fn) {
+        if (!this.eventListeners[eventName])
+            this.eventListeners[eventName] = {};
+        if (!this.eventListeners[eventName][id])
+            this.eventListeners[eventName][id] = [];
+        this.eventListeners[eventName][id].push(fn);
+    }
+    remove(id, eventName, fn) {
+        this.eventListeners[eventName][id] = this.eventListeners[eventName][id].filter(_fn => _fn !== fn);
+    }
+    send(id, eventName, data, callback, { bubble = true } = {}) {
+        const ids = Object.keys(this.eventListeners[eventName] || {}).filter(_id => id.startsWith(_id)).sort().reverse();
+        outer: for (let _id of ids) {
+            for (let listener of this.eventListeners[eventName][_id]) {
+                const result = listener(data, callback);
+                if (!bubble)
+                    break outer;
+                if (result === true || result === undefined) {
+                    return;
+                }
+            }
+        }
+        callback && callback();
+    }
+}
+exports.default = CustomEventService;

package/lib/services/dom-id-service.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Keeps track of reserved DOM IDs so that the IDs are rendered only once.
+ **/
+export default class DOMIdService {
+    private ids;
+    reserve: (id: string, sendId: (id: string) => void) => string | void;
+    release: (id: string, sendId: (id: string) => void) => void;
+}

package/lib/services/dom-id-service.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Keeps track of reserved DOM IDs so that the IDs are rendered only once.
+ **/
+class DOMIdService {
+    constructor() {
+        this.ids = {};
+        // First call returns id, next call (and only the very next) reserves the id until it is released.
+        this.reserve = (id, sendId) => {
+            if (this.ids[id] && this.ids[id].length) {
+                this.ids[id].push(sendId);
+            }
+            else {
+                this.ids[id] = [sendId]; // Just mark that the id is now used. It isn't reserved yet.
+                return id;
+            }
+        };
+        this.release = (id, sendId) => {
+            if (this.ids[id]) {
+                const idx = this.ids[id].indexOf(sendId);
+                this.ids[id].splice(idx, 1);
+                if (this.ids[id].length > 0) {
+                    this.ids[id][0](id);
+                }
+            }
+        };
+    }
+}
+exports.default = DOMIdService;

package/lib/services/focus-service.d.ts

@@ -0,0 +1,13 @@
+import { FormContext } from "../components/LajiForm";
+declare type FocusHandler = () => Promise<void> | void;
+export default class FocusService {
+    private formContext;
+    private focusHandlers;
+    constructor(formContext: FormContext);
+    setFormContext(formContext: FormContext): void;
+    addFocusHandler(id: string, fn: FocusHandler): void;
+    removeFocusHandler(id: string, fn: FocusHandler): void;
+    focus(id: string): void;
+    focusNextInput(reverse?: boolean): void;
+}
+export {};

package/lib/services/focus-service.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+class FocusService {
+    constructor(formContext) {
+        this.focusHandlers = {};
+        this.formContext = formContext;
+        this.focus = this.focus.bind(this);
+        this.focusNextInput = this.focusNextInput.bind(this);
+    }
+    setFormContext(formContext) {
+        this.formContext = formContext;
+    }
+    addFocusHandler(id, fn) {
+        if (!this.focusHandlers[id])
+            this.focusHandlers[id] = [];
+        this.focusHandlers[id].push(fn);
+    }
+    removeFocusHandler(id, fn) {
+        if (!this.focusHandlers[id]) {
+            console.warn(`laji-form warning: removing focus handler that isn't registered for id ${id}.`);
+            return;
+        }
+        this.focusHandlers[id] = this.focusHandlers[id].filter(_fn => fn !== _fn);
+    }
+    focus(id) {
+        const idParts = id.split("_");
+        // Some components focus asynchronously (due to state changes etc), so we reduce
+        // the focus handlers to a promise chain.
+        let _id = "";
+        idParts.reduce((promise, idPart) => {
+            return promise.then(() => {
+                _id = _id ? `${_id}_${idPart}` : idPart;
+                return (this.focusHandlers[_id] || []).reduce((_promise, fn) => {
+                    const status = fn(); // Either undefined or a Promise.
+                    return status && status.then ? status : Promise.resolve();
+                }, Promise.resolve());
+            });
+        }, Promise.resolve()).then(() => {
+            const container = this.formContext.utils.getSchemaElementById(id);
+            const elem = container || document.querySelector(`#laji-form-error-container-${id}`);
+            const input = document.querySelector(`#${id}`);
+            if (elem)
+                utils_1.scrollIntoViewIfNeeded(elem, this.formContext.topOffset, this.formContext.bottomOffset);
+            if (input && input.focus)
+                input.focus();
+            if (!elem)
+                return;
+            utils_1.highlightElem(elem);
+        });
+    }
+    focusNextInput(reverse = false) {
+        if (!this.formContext.formRef.current) {
+            console.warn("Focus service can't  doesn't have ref to the form");
+            return;
+        }
+        return this.formContext.utils.focusNextInput(reverse);
+    }
+}
+exports.default = FocusService;

package/lib/services/id-service.d.ts

@@ -0,0 +1,22 @@
+import { RJSFSchema } from "@rjsf/utils";
+export default class IdService {
+    private tmpIdTree;
+    private formData;
+    constructor(schema: RJSFSchema, formData: any);
+    setSchema(schema: RJSFSchema): void;
+    setFormData(formData: any): void;
+    addLajiFormIds(formData: any, immutably?: boolean): [any, {
+        [id: string]: true;
+    }];
+    getAllLajiFormIdsDeeply(formData: any): {
+        [id: string]: true;
+    };
+    removeLajiFormIds(formData: any): any;
+    getUUID: (item: any) => any;
+    findPointerForLajiFormId(tmpIdTree: any, formData: any, lajiFormId: string | number): string | undefined;
+    getJSONPointerFromLajiFormIdAndRelativePointer(lajiFormId: string | number, relativePointer: string): string;
+    getJSONPointerFromLajiFormIdAndFormDataAndIdSchemaId(idSchemaId: string, lajiFormId: string | number): string;
+    getRelativePointer(idSchemaId: string, lajiFormId: string | number): string | undefined;
+    getRelativeTmpIdTree(id: string): any;
+}
+export declare function createTmpIdTree(schema: RJSFSchema): {} | undefined;

package/lib/services/id-service.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTmpIdTree = void 0;
+const utils_1 = require("../utils");
+class IdService {
+    constructor(schema, formData) {
+        this.getUUID = (item) => item ? (item.id || item._lajiFormId) : undefined;
+        this.tmpIdTree = createTmpIdTree(schema);
+        this.formData = formData;
+    }
+    setSchema(schema) {
+        this.tmpIdTree = createTmpIdTree(schema);
+    }
+    setFormData(formData) {
+        this.formData = formData;
+    }
+    addLajiFormIds(formData, immutably = true) {
+        return utils_1.addLajiFormIds(formData, this.tmpIdTree, immutably);
+    }
+    getAllLajiFormIdsDeeply(formData) {
+        return utils_1.getAllLajiFormIdsDeeply(formData, this.tmpIdTree);
+    }
+    removeLajiFormIds(formData) {
+        return utils_1.removeLajiFormIds(formData, this.tmpIdTree);
+    }
+    findPointerForLajiFormId(tmpIdTree = {}, formData, lajiFormId) {
+        if (tmpIdTree._hasId) {
+            if (Array.isArray(formData)) {
+                for (let idx in (formData || [])) {
+                    const item = formData[idx];
+                    if (this.getUUID(item) === lajiFormId) {
+                        return "/" + idx;
+                    }
+                }
+            }
+            else if (formData && this.getUUID(formData) === lajiFormId) {
+                return "";
+            }
+        }
+        for (const k of Object.keys(tmpIdTree)) {
+            if (utils_1.isObject(formData[k])) {
+                const find = this.findPointerForLajiFormId(tmpIdTree[k], formData[k], lajiFormId);
+                if (find !== undefined || find === "") {
+                    return `/${k}${find}`;
+                }
+            }
+            else if (Array.isArray(formData[k])) {
+                for (const i in formData[k]) {
+                    const item = formData[k][i];
+                    const find = this.findPointerForLajiFormId(tmpIdTree[k], item, lajiFormId);
+                    if (find !== undefined || find === "") {
+                        return `/${k}/${i}${find}`;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    getJSONPointerFromLajiFormIdAndRelativePointer(lajiFormId, relativePointer) {
+        const containerPointer = this.findPointerForLajiFormId(this.tmpIdTree, this.formData, lajiFormId);
+        if (!containerPointer) {
+            return "";
+        }
+        return containerPointer + relativePointer;
+    }
+    getJSONPointerFromLajiFormIdAndFormDataAndIdSchemaId(idSchemaId, lajiFormId) {
+        const relativePointer = this.getRelativePointer(idSchemaId, lajiFormId);
+        return this.getJSONPointerFromLajiFormIdAndRelativePointer(lajiFormId, relativePointer || "");
+    }
+    getRelativePointer(idSchemaId, lajiFormId) {
+        var _a;
+        const containerPointer = this.findPointerForLajiFormId(this.tmpIdTree, this.formData, lajiFormId);
+        if (!containerPointer) {
+            return;
+        }
+        const indicesCount = ((_a = containerPointer.match(/\/[0-9]+/g)) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        const containerPointerWithoutArrayIndices = containerPointer.replace(/[0-9]+/g, "");
+        const thisPointer = idSchemaId.replace("root", "").replace(/_/g, "/");
+        let thisPointerWithoutContainerIndices = thisPointer;
+        for (let i = indicesCount; i > 0; i--) {
+            thisPointerWithoutContainerIndices = thisPointerWithoutContainerIndices.replace(/[0-9]+/, "");
+        }
+        return thisPointerWithoutContainerIndices.replace(containerPointerWithoutArrayIndices, "");
+    }
+    getRelativeTmpIdTree(id) {
+        let tmpIdTree = this.tmpIdTree;
+        if (!tmpIdTree) {
+            return undefined;
+        }
+        const treePath = id.replace(/root|_[0-9]+|_/g, "_").split("_").filter(i => i);
+        for (const k of treePath) {
+            if (tmpIdTree[k]) {
+                tmpIdTree = tmpIdTree[k];
+            }
+            else {
+                tmpIdTree = undefined;
+                break;
+            }
+        }
+        return tmpIdTree;
+    }
+}
+exports.default = IdService;
+function createTmpIdTree(schema) {
+    function walk(_schema) {
+        if (_schema.properties) {
+            const _walked = Object.keys(_schema.properties).reduce((paths, key) => {
+                const walked = walk(_schema.properties[key]);
+                if (walked) {
+                    paths[key] = walked;
+                }
+                return paths;
+            }, {});
+            if (Object.keys(_walked).length)
+                return _walked;
+        }
+        else if (_schema.type === "array" && _schema.items.type === "object") {
+            return Object.keys(_schema.items.properties).reduce((paths, key) => {
+                const walked = walk(_schema.items.properties[key]);
+                if (walked) {
+                    paths[key] = walked;
+                }
+                return paths;
+            }, { _hasId: true });
+        }
+        return undefined;
+    }
+    return walk(schema);
+}
+exports.createTmpIdTree = createTmpIdTree;

package/lib/services/key-handler-service.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="react" />
+import { FormContext } from "../components/LajiForm";
+export declare type KeyFunctions = {
+    [fnName: string]: (e: KeyboardEvent, options: any) => boolean | void;
+};
+interface ShortcutKey {
+    fn: string;
+    target?: string;
+    [param: string]: any;
+}
+export declare type ShortcutKeys = Record<string, ShortcutKey>;
+export interface InternalKeyHandler extends ShortcutKey {
+    conditions: ((e: KeyboardEvent) => boolean)[];
+}
+declare type InternalKeyHandlers = InternalKeyHandler[];
+/**
+ *
+ * A service for adding key listeners. Key events are handled in a custom event handling system, which allows many useful
+ * features like listening to DOM document root, fine grained control over the order of event bubbling etc and passing any
+ * needed data to the event handler.
+ *
+ * When initialized, it adds a global keydown listener to the document which handles the LajiForm key shortcuts defined in
+ * uiSchema["ui:shortcuts"].
+ *
+ **/
+export default class KeyhandlerService {
+    shortcuts: ShortcutKeys;
+    private keyHandlers;
+    private keyHandlerTargets;
+    private keyHandleListeners;
+    private keyHandleIdFunctions;
+    private blocked;
+    private formContext;
+    private globalEventsRootHandler;
+    private globalEventHandlers;
+    constructor(formContext: FormContext);
+    initialize(): void;
+    destroy(): void;
+    block(): void;
+    unblock(): void;
+    setShortcuts(shortcuts: ShortcutKeys | undefined, keyFunctions: KeyFunctions): void;
+    setFormContext(formContext: FormContext): void;
+    getKeyHandlers(shortcuts?: ShortcutKeys): InternalKeyHandlers;
+    addKeyHandler: (id: string, keyFunctions: KeyFunctions, additionalParams?: any) => void;
+    removeKeyHandler: (_id: string, _keyFunctions: {
+        [fnName: string]: () => boolean | void;
+    }) => void;
+    onKeyDown(e: KeyboardEvent): void;
+    /**
+     * Global event handlers are listened for the whole DOM document. React can't listen to events on document level, hence this is useful.
+     **/
+    addGlobalEventHandler(name: string, fn: React.EventHandler<any>): void;
+    removeGlobalEventHandler(name: string, fn: React.EventHandler<any>): void;
+    private handleKeysWith;
+}
+export {};