@luomus/laji-form 15.1.90 → 15.1.92

package/lib/components/LajiForm.js

@@ -146,6 +146,7 @@ const fields = importLocalComponents("fields", [
     "MultiActiveArrayField",
     "PrefixArrayField",
     "FillDateRangeField",
+    "TaxonSetPopulatorField",
     "ScientificNameTaxonAutosuggestField",
     { "InputTransformerField": "ConditionalOnChangeField" }, // Alias for backward compatibility.
     { "ConditionalField": "ConditionalUiSchemaField" }, // Alias for backward compatibility.

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

@@ -22,6 +22,12 @@ export default class MultiAnyToBooleanField extends React.Component<any, any, an
     getInitialState(props: any): {
         groupsFormData: any[];
     };
+    getStateFromProps(props: any): {
+        groupsFormData: any[];
+    };
+    initializeGroups: (props: any) => {
+        groupsFormData: any[];
+    };
     onChange: (index: any) => (value: any) => void;
     render(): JSX.Element;
 }

package/lib/components/fields/MultiAnyToBooleanField.js

@@ -62,6 +62,31 @@ const utils_2 = require("@rjsf/utils");
 let MultiAnyToBooleanField = class MultiAnyToBooleanField extends React.Component {
     constructor(props) {
         super(props);
+        this.initializeGroups = (props) => {
+            let { groups } = (0, utils_1.getUiOptions)(props.uiSchema) || [];
+            const { formData } = props;
+            const trueValues = groups.map(group => group.trueValue);
+            const falseValues = groups.map(group => group.falseValue);
+            const groupsFormData = [];
+            if (formData) {
+                formData.forEach(value => {
+                    if (value === undefined) {
+                        return;
+                    }
+                    const trueIndex = trueValues.findIndex(trueValue => props.formContext.utils.formDataEquals(value, trueValue, props.idSchema.$id));
+                    if (trueIndex !== -1) {
+                        groupsFormData[trueIndex] = value;
+                    }
+                    else {
+                        const falseIndex = falseValues.findIndex(falseValue => props.formContext.utils.formDataEquals(value, falseValue, props.idSchema.$id));
+                        if (falseIndex !== -1) {
+                            groupsFormData[falseIndex] = value;
+                        }
+                    }
+                });
+            }
+            return { groupsFormData: groupsFormData };
+        };
         this.onChange = (index) => (value) => {
             const groupsFormData = this.state.groupsFormData;
             groupsFormData[index] = value;
@@ -77,29 +102,10 @@ let MultiAnyToBooleanField = class MultiAnyToBooleanField extends React.Componen
         this.state = this.getInitialState(props);
     }
     getInitialState(props) {
-        let { groups } = (0, utils_1.getUiOptions)(props.uiSchema) || [];
-        const { formData } = props;
-        const trueValues = groups.map(group => group.trueValue);
-        const falseValues = groups.map(group => group.falseValue);
-        const groupsFormData = [];
-        if (formData) {
-            formData.forEach(value => {
-                if (value === undefined) {
-                    return;
-                }
-                const trueIndex = trueValues.findIndex(trueValue => props.formContext.utils.formDataEquals(value, trueValue, props.idSchema.$id));
-                if (trueIndex !== -1) {
-                    groupsFormData[trueIndex] = value;
-                }
-                else {
-                    const falseIndex = falseValues.findIndex(falseValue => props.formContext.utils.formDataEquals(value, falseValue, props.idSchema.$id));
-                    if (falseIndex !== -1) {
-                        groupsFormData[falseIndex] = value;
-                    }
-                }
-            });
-        }
-        return { groupsFormData: groupsFormData };
+        return this.initializeGroups(props);
+    }
+    getStateFromProps(props) {
+        return this.initializeGroups(props);
     }
     render() {
         const TitleFieldTemplate = (0, utils_2.getTemplate)("TitleFieldTemplate", this.props.registry, (0, utils_1.getUiOptions)(this.props.uiSchema));

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

@@ -0,0 +1,50 @@
+import * as React from "react";
+import * as PropTypes from "prop-types";
+import { FieldProps } from "../../types";
+/**
+ * Watches a specified field which contains taxon set IDs.
+ *
+ * When taxon set IDs are added, it fetches the taxa in those sets from the API and adds them to the units in formData.
+ *
+ * When taxon set IDs are removed, it removes any taxa belonging to those sets from the units in formData.
+ *
+ * uiSchema = {
+ *   "ui:field": "TaxonSetPopulatorField",
+ *   "ui:options": {
+ *     "props": {
+ *       "from": "taxonCensus",                    	// Source object containing taxon set IDs
+ *       "fromArrayKey": "censusTaxonSetID",      	// Field within source object containing the taxon set IDs
+ *    	 "joinArray": true,                      	// Join array of IDs into comma-separated string
+ *     }
+ *   }
+ * }
+ */
+export default class TaxonSetPopulatorField extends React.Component<FieldProps> {
+    static propTypes: {
+        uiSchema: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            "ui:options": PropTypes.Requireable<PropTypes.InferProps<{
+                props: PropTypes.Requireable<NonNullable<PropTypes.InferProps<{
+                    from: PropTypes.Validator<string>;
+                    fromArrayKey: PropTypes.Requireable<string>;
+                    joinArray: PropTypes.Requireable<boolean>;
+                }> | (PropTypes.InferProps<{
+                    from: PropTypes.Validator<string>;
+                    fromArrayKey: PropTypes.Requireable<string>;
+                    joinArray: PropTypes.Requireable<boolean>;
+                }> | null | undefined)[] | null | undefined>>;
+            }>>;
+            uiSchema: PropTypes.Requireable<object>;
+        }>>>;
+        schema: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            type: PropTypes.Requireable<string>;
+        }>>>;
+        formData: PropTypes.Validator<object>;
+    };
+    static getName(): string;
+    taxonSets: any[];
+    getStateFromProps(): {
+        onChange: (formData: any) => Promise<void>;
+    };
+    onChange: (formData: any) => Promise<void>;
+    private fetchTaxaFromSet;
+}

package/lib/components/fields/TaxonSetPopulatorField.js

@@ -0,0 +1,206 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const React = __importStar(require("react"));
+const PropTypes = __importStar(require("prop-types"));
+const VirtualSchemaField_1 = __importDefault(require("../VirtualSchemaField"));
+const propsPropType = PropTypes.shape({
+    from: PropTypes.string.isRequired,
+    fromArrayKey: PropTypes.string,
+    joinArray: PropTypes.bool,
+});
+/**
+ * Watches a specified field which contains taxon set IDs.
+ *
+ * When taxon set IDs are added, it fetches the taxa in those sets from the API and adds them to the units in formData.
+ *
+ * When taxon set IDs are removed, it removes any taxa belonging to those sets from the units in formData.
+ *
+ * uiSchema = {
+ *   "ui:field": "TaxonSetPopulatorField",
+ *   "ui:options": {
+ *     "props": {
+ *       "from": "taxonCensus",                    	// Source object containing taxon set IDs
+ *       "fromArrayKey": "censusTaxonSetID",      	// Field within source object containing the taxon set IDs
+ *    	 "joinArray": true,                      	// Join array of IDs into comma-separated string
+ *     }
+ *   }
+ * }
+ */
+let TaxonSetPopulatorField = class TaxonSetPopulatorField extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.taxonSets = [];
+        this.onChange = (formData) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const previousTaxonSets = this.taxonSets;
+            const currentTaxonSets = ((_a = formData === null || formData === void 0 ? void 0 : formData.taxonCensus) === null || _a === void 0 ? void 0 : _a.map((item) => item.censusTaxonSetID)) || [];
+            const deletedTaxonSets = previousTaxonSets.filter((item) => !currentTaxonSets.includes(item));
+            const addedTaxonSets = currentTaxonSets.filter((item) => !previousTaxonSets.includes(item));
+            this.taxonSets = ((_b = formData === null || formData === void 0 ? void 0 : formData.taxonCensus) === null || _b === void 0 ? void 0 : _b.map((item) => item.censusTaxonSetID)) || [];
+            if (deletedTaxonSets.length > 0) {
+                deletedTaxonSets.map((deletedTaxonSetId) => {
+                    var _a;
+                    const currentUnits = Array.isArray((_a = this.props.formData) === null || _a === void 0 ? void 0 : _a.units) ? this.props.formData.units : [];
+                    let observationsExist = false;
+                    const deletedTaxonSetUnits = currentUnits.filter((unit) => {
+                        return unit.taxonSets && unit.taxonSets.includes(deletedTaxonSetId);
+                    });
+                    deletedTaxonSetUnits.map((unit) => {
+                        var _a, _b, _c, _d;
+                        if (unit.maleIndividualCount ||
+                            unit.femaleIndividualCount ||
+                            unit.nestCount ||
+                            ((_a = unit.unitFact) === null || _a === void 0 ? void 0 : _a.destroyedNestCount) ||
+                            ((_b = unit.unitFact) === null || _b === void 0 ? void 0 : _b.broodCount) ||
+                            ((_c = unit.unitFact) === null || _c === void 0 ? void 0 : _c.femalesWithBroodsCount) ||
+                            ((_d = unit.unitFact) === null || _d === void 0 ? void 0 : _d.juvenileCount)) {
+                            window.alert(`Warning: Can't delete taxon set "${deletedTaxonSetId}" because it has observations.`);
+                            observationsExist = true;
+                            const updatedFormData = Object.assign(Object.assign({}, formData), { taxonCensus: [
+                                    ...formData.taxonCensus,
+                                    {
+                                        censusTaxonSetID: deletedTaxonSetId,
+                                        taxonCensusType: "MY.taxonCensusTypeCounted"
+                                    }
+                                ] });
+                            this.taxonSets = [...this.taxonSets, deletedTaxonSetId];
+                            this.props.onChange(updatedFormData);
+                            return;
+                        }
+                    });
+                    if (observationsExist) {
+                        return;
+                    }
+                    const updatedUnits = currentUnits.filter((unit) => {
+                        return !unit.taxonSets || !unit.taxonSets.includes(deletedTaxonSetId);
+                    });
+                    const updatedFormData = Object.assign(Object.assign({}, formData), { units: updatedUnits });
+                    this.props.onChange(updatedFormData);
+                });
+            }
+            if (addedTaxonSets.length > 0) {
+                const currentUnits = Array.isArray((_c = this.props.formData) === null || _c === void 0 ? void 0 : _c.units) ? this.props.formData.units : [];
+                // if current units include any units with taxon sets that are being added, return to avoid duplicates
+                const duplicateUnits = currentUnits.filter((unit) => {
+                    return unit.taxonSets && unit.taxonSets.some((taxonSetId) => addedTaxonSets.includes(taxonSetId));
+                });
+                if (duplicateUnits.length > 0) {
+                    return;
+                }
+                const results = yield this.fetchTaxaFromSet(this.props, addedTaxonSets);
+                const newUnits = results.map((result) => {
+                    return {
+                        identifications: [{
+                                taxon: result.scientificName,
+                                taxonID: result.id,
+                                taxonVerbatim: result.vernacularName
+                            }],
+                        informalTaxonGroups: result.informalTaxonGroups || [],
+                        taxonSets: result.taxonSets || []
+                    };
+                });
+                const updatedFormData = Object.assign(Object.assign({}, formData), { units: [...currentUnits, ...newUnits] });
+                this.props.onChange(updatedFormData);
+            }
+        });
+    }
+    static getName() {
+        return "TaxonSetPopulatorField";
+    }
+    getStateFromProps() {
+        return { onChange: this.onChange };
+    }
+    fetchTaxaFromSet(props, taxonSets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const apiClient = (_a = props.formContext) === null || _a === void 0 ? void 0 : _a.apiClient;
+            if (!apiClient) {
+                return [];
+            }
+            try {
+                const response = yield apiClient.post("/taxa", {
+                    query: {
+                        pageSize: 1000,
+                        selectedFields: ["id", "scientificName", "vernacularName", "informalTaxonGroups", "taxonSets"]
+                    }
+                }, {
+                    taxonSets
+                });
+                if (!response.results || !Array.isArray(response.results)) {
+                    return [];
+                }
+                return response.results;
+            }
+            catch (error) {
+                return [];
+            }
+        });
+    }
+};
+TaxonSetPopulatorField.propTypes = {
+    uiSchema: PropTypes.shape({
+        "ui:options": PropTypes.shape({
+            props: PropTypes.oneOfType([PropTypes.arrayOf(propsPropType), propsPropType])
+        }),
+        uiSchema: PropTypes.object
+    }).isRequired,
+    schema: PropTypes.shape({
+        type: PropTypes.oneOf(["array", "object"])
+    }).isRequired,
+    formData: PropTypes.oneOfType([PropTypes.array, PropTypes.object]).isRequired
+};
+TaxonSetPopulatorField = __decorate([
+    VirtualSchemaField_1.default
+], TaxonSetPopulatorField);
+exports.default = TaxonSetPopulatorField;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luomus/laji-form",
-  "version": "15.1.90",
+  "version": "15.1.92",
   "description": "React module capable of building dynamic forms from Laji form json schemas",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",