@luomus/laji-form 15.0.0 → 15.1.1

package/lib/components/fields/PrefillingArrayField.js

@@ -1,65 +0,0 @@
-"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

@@ -1,7 +0,0 @@
-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

@@ -1,109 +0,0 @@
-"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

@@ -1,85 +0,0 @@
-/**
- * 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";