@luomus/laji-form 15.1.4 → 15.1.6

package/lib/components/fields/SelectTreeField.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Constructs selects from given tree.
+ * uiSchema = {"ui:options": {
+*   tree: {<enum key tree>}, (node object: {children: {key: {<node>}, key2:{<node>}}, order: ["key", "key2"]} (order is optional)
+*   labels: [<string>]
+ * }
+ */
+export default class SelectTreeField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Validator<PropTypes.InferProps<{
+                tree: PropTypes.Validator<object>;
+                labels: PropTypes.Requireable<(string | null | undefined)[]>;
+                uiSchema: PropTypes.Requireable<object>;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        value: PropTypes.Requireable<string>;
+    };
+    constructor(props: any);
+    constructor(props: any, context: any);
+    getStateFromProps(props: any): {
+        schema: {
+            type: string;
+            title: any;
+        };
+        formData: {};
+        uiSchema: any;
+        idSchema: {
+            $id: any;
+        };
+    };
+    onChange: (formData: any) => void;
+    onKeyDown: (e: any) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";

package/lib/components/fields/SelectTreeField.js

@@ -0,0 +1,143 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = require("react");
+const PropTypes = require("prop-types");
+const utils_1 = require("../../utils");
+const BaseComponent_1 = require("../BaseComponent");
+/**
+ * Constructs selects from given tree.
+ * uiSchema = {"ui:options": {
+*   tree: {<enum key tree>}, (node object: {children: {key: {<node>}, key2:{<node>}}, order: ["key", "key2"]} (order is optional)
+*   labels: [<string>]
+ * }
+ */
+let SelectTreeField = class SelectTreeField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.onChange = (formData) => {
+            let selectNames = Object.keys(formData).sort((a, b) => { return b - a; });
+            for (let i in selectNames) {
+                if (formData[i] !== this.state.formData[i]) {
+                    let value;
+                    if (utils_1.isEmptyString(formData[i])) {
+                        value = (i > 0) ? formData[i - 1] : undefined;
+                    }
+                    else {
+                        value = formData[i];
+                    }
+                    this.props.onChange(value);
+                    break;
+                }
+            }
+        };
+        this.onKeyDown = (e) => {
+            if (e.key == "Enter" && !e.ctrlKey) {
+                e.preventDefault();
+                e.stopPropagation();
+                this.props.formContext.setTimeout(() => {
+                    this.props.formContext.services.focus.focusNextInput(e.shiftKey);
+                });
+            }
+        };
+    }
+    getStateFromProps(props) {
+        let schema = { "type": "object", title: props.schema.title };
+        let { uiSchema } = props;
+        uiSchema = utils_1.getInnerUiSchema(props.uiSchema);
+        let formData = {};
+        let idSchema = { $id: props.idSchema.$id };
+        let dictionarifiedEnums = {};
+        props.schema.oneOf.forEach(e => {
+            dictionarifiedEnums[e.const] = e.title;
+        });
+        let { tree, labels } = utils_1.getUiOptions(props.uiSchema);
+        let levels = [];
+        let parentsMap = {};
+        let childrenMap = {};
+        let orderMap = {};
+        function getLevels(tree, depth, root) {
+            childrenMap[root] = {};
+            if (tree.children)
+                Object.keys(tree.children).forEach(key => {
+                    if (!levels[depth])
+                        levels[depth] = {};
+                    levels[depth][key] = true;
+                    parentsMap[key] = root;
+                    childrenMap[root][key] = true;
+                    getLevels(tree.children[key], depth + 1, key);
+                });
+            if (tree.order)
+                orderMap[root] = tree.order;
+        }
+        getLevels(tree, 0);
+        let properties = {};
+        function addSelect(depth, key, childrenKeys) {
+            let select = { "type": "string", oneOf: [{ const: "", title: "" }] };
+            let order = orderMap[key];
+            if (order)
+                childrenKeys.sort((a, b) => { return order.indexOf(a) - order.indexOf(b); });
+            childrenKeys.forEach(key => {
+                select.oneOf.push({ const: key, title: dictionarifiedEnums[key] });
+            });
+            if (labels && labels[depth]) {
+                select.title = labels[depth];
+            }
+            select.title = (labels && labels[depth]) ? labels[depth] : "";
+            properties[depth] = select;
+            idSchema[depth] = { $id: idSchema.$id + "_" + depth };
+        }
+        let searchTerm = props.formData;
+        let depth = 0;
+        if (!utils_1.isEmptyString(searchTerm))
+            for (let i in levels) {
+                let level = levels[i];
+                if (level[searchTerm])
+                    break;
+                depth++;
+            }
+        let n = searchTerm;
+        let d = depth;
+        while (d >= 0) {
+            formData[d] = n;
+            if (utils_1.isEmptyString(n))
+                n = undefined; //object keys can't be "", so root key is in childrenMap 'undefined'.
+            addSelect(d, n, Object.keys(childrenMap[parentsMap[n]]));
+            d--;
+            n = parentsMap[n];
+        }
+        if (!utils_1.isEmptyString(searchTerm) && childrenMap[searchTerm] && Object.keys(childrenMap[searchTerm]).length) {
+            addSelect(depth + 1, searchTerm, Object.keys(childrenMap[searchTerm]));
+            formData[depth + 1] = undefined;
+        }
+        schema.properties = properties;
+        return { schema, formData, uiSchema, idSchema };
+    }
+    render() {
+        const SchemaField = this.props.registry.fields.SchemaField;
+        return (React.createElement("div", { onKeyDown: this.onKeyDown },
+            React.createElement(SchemaField, Object.assign({}, this.props, this.state, { onChange: this.onChange }))));
+    }
+};
+SelectTreeField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            tree: PropTypes.object.isRequired,
+            labels: PropTypes.arrayOf(PropTypes.string),
+            uiSchema: PropTypes.object
+        }).isRequired
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["string"])
+    }).isRequired,
+    value: PropTypes.string
+};
+SelectTreeField = __decorate([
+    BaseComponent_1.default
+], SelectTreeField);
+exports.default = SelectTreeField;

package/lib/components/fields/SingleActiveArrayField.d.ts

@@ -0,0 +1,49 @@
+export default class SingleActiveArrayField extends React.Component<any, any, any> {
+    static propTypes: {
+        uiSchema: PropTypes.Requireable<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                renderer: PropTypes.Requireable<string>;
+                activeIdx: PropTypes.Requireable<number>;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Requireable<any[]>;
+    };
+    constructor(props: any);
+    deleteButtonRefs: {};
+    deleteButtonRefSetters: {};
+    getInitialActiveIdx: (props: any) => any;
+    mounted: boolean | undefined;
+    prevActiveIdx: any;
+    updatePopups: (props: any) => void;
+    getStateFromProps(props: any): {
+        activeIdx: any;
+    };
+    onHeaderAffixChange: (elem: any, value: any) => void;
+    getLocalFormContext: () => any;
+    localContextKey: any;
+    localContext: any;
+    updateRenderingMode: (normalRendering: any, callback: any) => void;
+    getPopupDataPromise: (idx: any, props: any, itemFormData: any) => Promise<any>;
+    onActiveChange: (idx: any, prop: any, callback: any) => void;
+    onDelete: (item: any) => (e: any) => void;
+    buttonDefinitions: {
+        add: {
+            callback: () => void;
+        };
+        addPredefined: {
+            callback: () => void;
+        };
+        copy: {
+            fn: () => (...params: any[]) => void;
+            callback: () => void;
+            rules: {
+                minLength: number;
+            };
+        };
+    };
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";