@luomus/laji-form 15.1.4 → 15.1.6

package/lib/components/fields/PrefillingArrayField.js

@@ -0,0 +1,65 @@
+"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 VirtualSchemaField_1 = require("../VirtualSchemaField");
+let PrefillingArrayField = class PrefillingArrayField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.mapFormData = (formData) => {
+            const prefiller = formData.prefiller;
+            return (formData.rest && formData.rest.length
+                ? formData.rest
+                : [utils_1.getDefaultFormState(this.props.schema.items)]).map(item => {
+                return Object.assign(Object.assign({}, item), { [this.getUiOptions().field]: prefiller });
+            });
+        };
+        this.onChange = (formData) => {
+            this.props.onChange(this.mapFormData(formData));
+        };
+    }
+    static getName() { return "PrefillingArrayField"; }
+    getStateFromProps(props) {
+        const { field, uiSchema } = this.getUiOptions();
+        return Object.assign(Object.assign({}, props), { schema: {
+                type: "object",
+                title: "",
+                properties: {
+                    prefiller: props.schema.items.properties[field],
+                    rest: props.schema
+                }
+            }, uiSchema: {
+                prefiller: uiSchema || props.uiSchema.items[field],
+                rest: props.formData && props.formData.length ? props.uiSchema : Object.assign(Object.assign({}, props.uiSchema), { "ui:options": Object.assign(Object.assign({}, props.uiSchema["ui:options"]), { canAdd: false }) }),
+            }, formData: {
+                prefiller: ((props.formData || [])[0] || {})[field],
+                rest: props.formData
+            }, idSchema: {
+                prefiller: { prefiller: `${props.idSchema.$id}_${field}` },
+                rest: props.idSchema
+            }, onChange: this.onChange });
+    }
+};
+PrefillingArrayField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            field: PropTypes.string,
+            uiSchema: PropTypes.object
+        })
+    }),
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array"])
+    }).isRequired,
+    formData: PropTypes.array.isRequired
+};
+PrefillingArrayField = __decorate([
+    VirtualSchemaField_1.default
+], PrefillingArrayField);
+exports.default = PrefillingArrayField;

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

@@ -0,0 +1,7 @@
+export default class _SchemaField extends React.Component<any, any, any> {
+    constructor(props: any);
+    updateVirtualInstance: (props: any, initial: any) => void;
+    functionOutputProps: any;
+    applyFunction(props: any): any;
+}
+import * as React from "react";

package/lib/components/fields/SchemaField.js

@@ -0,0 +1,109 @@
+"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 React = require("react");
+const utils_1 = require("../../utils");
+const utils_2 = require("@luomus/laji-map/lib/utils");
+const ContextInjectionField_1 = require("./ContextInjectionField");
+const utils_3 = require("@rjsf/utils");
+const core_1 = require("@rjsf/core");
+class _SchemaField extends React.Component {
+    constructor(props) {
+        super(props);
+        this.updateVirtualInstance = (props, initial) => {
+            const virtualizedProps = ["ui:functions", "ui:childFunctions", "ui:annotations", "ui:multiLanguage"];
+            if ([props, this.props].some(_props => _props.uiSchema && virtualizedProps.some(prop => _props.uiSchema[prop])) &&
+                (initial || !utils_3.deepEquals(this.props, props))) {
+                this.functionOutputProps = this.applyFunction(props);
+            }
+        };
+        this.updateVirtualInstance(props, !!"initial");
+        this.state = { showAnnotations: false };
+    }
+    UNSAFE_componentWillReceiveProps(props) {
+        this.updateVirtualInstance(props);
+    }
+    applyFunction(props) {
+        let _a = (props.uiSchema || {}), { "ui:functions": functions, "ui:childFunctions": childFunctions, "ui:annotations": annotations, "ui:multiLanguage": multiLanguage } = _a, _uiSchema = __rest(_a, ["ui:functions", "ui:childFunctions", "ui:annotations", "ui:multiLanguage"]);
+        const objectOrArrayAsArray = item => (item
+            ? (Array.isArray(item)
+                ? item
+                : [item])
+            : []);
+        functions = objectOrArrayAsArray(functions);
+        if (childFunctions) {
+            functions = [
+                { "ui:field": "UiFieldMapperArrayField", "ui:options": { functions: childFunctions } },
+                ...functions
+            ];
+        }
+        if (annotations) {
+            functions = [
+                { "ui:field": "AnnotationField", "ui:options": (utils_2.isObject(annotations) ? annotations : {}) },
+                ...functions
+            ];
+        }
+        if (multiLanguage) {
+            functions = [
+                { "ui:field": "MultiLanguageField" },
+                ...functions
+            ];
+        }
+        if (!functions.length)
+            return props;
+        let _props = Object.assign(Object.assign({}, props), { uiSchema: _uiSchema });
+        let [uiFn, ...restUiFns] = functions;
+        const { "ui:injections": injections } = uiFn;
+        if (injections) {
+            const injectedUiSchema = ContextInjectionField_1.getInjectedUiSchema(uiFn, injections, props.registry.formContext.uiSchemaContext);
+            uiFn = Object.assign(Object.assign({}, injectedUiSchema), { "ui:injections": undefined });
+        }
+        const buttons = !_props.uiSchema["ui:field"] ? utils_1.getUiOptions(_props.uiSchema).buttons : undefined;
+        const uiButtons = !_props.uiSchema["ui:field"] ? utils_1.getUiOptions(_props.uiSchema)["ui:buttons"] : undefined;
+        _props = Object.assign(Object.assign({}, _props), { uiSchema: (_props.uiSchema["ui:field"] || _props.uiSchema["ui:widget"])
+                ? Object.assign(Object.assign({}, uiFn), { uiSchema: _props.uiSchema }) : Object.assign(Object.assign({}, _props.uiSchema), uiFn) });
+        if (buttons || uiButtons) {
+            _props = Object.assign(Object.assign({}, _props), { uiSchema: Object.assign(Object.assign({}, _props.uiSchema), { "ui:options": Object.assign(Object.assign({}, _props.uiSchema["ui:options"]), { buttons: [...(_props.uiSchema.buttons || []), ...(buttons || [])], "ui:buttons": [...(_props.uiSchema["ui:buttons"] || []), ...(uiButtons || [])] }) }) });
+        }
+        return Object.assign(Object.assign({}, _props), { uiSchema: Object.assign(Object.assign({}, _props.uiSchema), { "ui:functions": restUiFns }) });
+    }
+    render() {
+        const props = this.functionOutputProps || this.props;
+        let { schema, uiSchema = {}, formContext, registry } = props, _props = __rest(props, ["schema", "uiSchema", "formContext", "registry"]); // eslint-disable-line @typescript-eslint/no-unused-vars
+        const { formContext: _formContext } = registry;
+        if (schema.uniqueItems && schema.items.enum && !utils_1.isMultiSelect(schema, uiSchema) && schema.uniqueItems) {
+            schema = Object.assign(Object.assign({}, schema), { uniqueItems: false });
+        }
+        const options = utils_1.getUiOptions(uiSchema);
+        if (typeof options.label === "string") {
+            schema = Object.assign(Object.assign({}, schema), { title: options.label });
+        }
+        const { "ui:injections": injections } = uiSchema;
+        if (injections) {
+            const injectedUiSchema = ContextInjectionField_1.getInjectedUiSchema(uiSchema, injections, _formContext.uiSchemaContext);
+            uiSchema = Object.assign(Object.assign({}, injectedUiSchema), { "ui:injections": undefined });
+        }
+        // Remove unnecessary formDataTransformers in order to prevent unnecessary rendering.
+        if (_formContext && _formContext.formDataTransformers && _formContext.formDataTransformers.length) {
+            const removeIdxs = /\d+_?/g;
+            const idWithoutIdxs = this.props.idSchema.$id.replace(removeIdxs, "");
+            const filtered = _formContext.formDataTransformers.filter(({ targets }) => targets.some(target => target.replace(removeIdxs, "").startsWith(idWithoutIdxs)));
+            if (filtered.length !== _formContext.formDataTransformers.length) {
+                registry = Object.assign(Object.assign({}, registry), { formContext: Object.assign(Object.assign({}, _formContext), { formDataTransformers: filtered }) });
+            }
+        }
+        const { SchemaField } = core_1.getDefaultRegistry().fields;
+        return React.createElement(SchemaField, Object.assign({}, _props, { registry: registry, schema: schema, uiSchema: uiSchema }));
+    }
+}
+exports.default = _SchemaField;

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

@@ -0,0 +1,85 @@
+/**
+ * Field with fields, which are shown according to recursive scope.
+ * uiSchema = {"ui:options": {
+ * additionalsGroupingPath: path to the field scope that defines groups
+ * additionalsGroupsTranslator: one of scopeFieldsSettings translator
+ * additionalsPersistenceKey: instances with same persistence id use the same additional fields
+ * additionalsPersistenceField: form data property value for more fine grained persistence behaviour
+ * uiSchema: <uiSchema> (ui schema for inner schema)
+ * fields: [<string>] (fields that are always shown)
+ * fieldScopes: {
+ *  fieldName: {
+ *    fieldValue: {
+ *      fields: [<string>] (fields that are shown if fieldName[fieldValue} == true)
+ *      additionalFields: [<string>] (if grouping is enabled, additional fields are shown only if selected from the list)
+ *      excludeFields: [<string>] (exclude fields from showing)
+ *      excludeFields: [<string>] (fields that are shown by default)
+ *      refs: [<string>] (root definitions that are merged recursively to this fieldScope)
+ *      uiSchema: <uiSchema> (merged recursively to inner uiSchema)
+ *      uiSchemaMergeType: See documentation for ConditionalUiSchemaField
+ *      fieldScopes: {fieldName: <fieldScope>, fieldName2 ...}
+ *    },
+ *    fieldValue2, ...
+ *  }
+ * },
+ * definitions: {
+ *   defName: <fieldScope>,
+ *   defname2: ...
+ * }
+ * }
+ *
+ * Field scope values accept asterisk (*) and plus (+) as field scope selector.
+ */
+export default class ScopeField extends React.Component<any, any, any> {
+    static contextType: React.Context<import("../../ReactContext").ContextProps>;
+    static propTypes: {
+        uiSchema: PropTypes.Validator<PropTypes.InferProps<{
+            "ui:options": PropTypes.Validator<PropTypes.InferProps<{
+                includeAdditionalFieldsChooserButton: any;
+                additionalsGroupingPath: PropTypes.Requireable<string>;
+                additionalsGroupsTranslator: PropTypes.Requireable<string>;
+                additionalsPersistenceKey: PropTypes.Requireable<string>;
+                additionalsPersistenceField: PropTypes.Requireable<string>;
+                fieldScopes: PropTypes.Requireable<object>;
+                fields: PropTypes.Requireable<(string | null | undefined)[]>;
+                definitions: PropTypes.Requireable<object>;
+                uiSchema: PropTypes.Requireable<object>;
+            }>>;
+        }>>;
+        schema: PropTypes.Validator<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>;
+        formData: PropTypes.Validator<object>;
+    };
+    constructor(props: any);
+    mounted: boolean | undefined;
+    getAdditionalPersistenceValue: (props: any, includeUndefined?: boolean) => any[];
+    getStateFromProps(props: any): {
+        includeAdditionalFieldsChooserButton: boolean;
+    };
+    _globals: any;
+    getSchemasAndAdditionals: (props: any, state: any) => {
+        schema: any;
+        uiSchema: any;
+        additionalFields: any;
+        defaultFields: any;
+        fieldsToShow: {};
+    };
+    onToggleAdditionals: () => void;
+    renderAdditionalsButtons: () => any;
+    onSelect: () => void;
+    preventCloseDropdown: boolean | undefined;
+    onToggle: (isOpen: any) => void;
+    renderFieldsDropdown(additionalProperties: any): JSX.Element;
+    renderFieldsModal: (additionalProperties: any) => JSX.Element;
+    modal: JSX.Element | undefined;
+    renderFieldsButton: (bsRole: any) => JSX.Element;
+    renderGlyphFields: () => any;
+    propertyIsIncluded: (property: any) => boolean;
+    toggleAdditionalProperty: (fields: any) => void;
+    additionalPropertiesToList: (properties: any, ElemType: any) => JSX.Element[];
+    propertyTogglers: {} | undefined;
+    translateAdditionalsGroups: (props: any) => void;
+}
+import * as React from "react";
+import * as PropTypes from "prop-types";