@hestia-earth/ui-components 0.0.1

package/esm2015/files/files-form.model.js

@@ -0,0 +1,548 @@
+import { __rest } from "tslib";
+/* eslint-disable complexity */
+const get = require('lodash.get');
+import * as moment from 'moment';
+import 'moment/locale/en-gb';
+import { v4 as uuidv4 } from 'uuid';
+import { diffInDays, isNumber } from '@hestia-earth/utils';
+import { SchemaType, NodeType, isTypeNode, isTypeValid, isExpandable, typeToSchemaType } from '@hestia-earth/schema';
+import { formatCustomErrorMessage, formatError, missingNodeErrorMessage, isMissingPropertyError, errorHasError, errorHasWarning, missingNodeErrors, isMissingOneOfError } from './files-error.model';
+import { schemaRequiredProperties, valueTypeToDefault, definitionToSchemaType, availableProperties, nestingTypeEnabled, nestingEnabled, linkTypeEnabled, isSchemaIri } from '../schema/schema.service';
+import { matchCountry } from '../search/search.model';
+import { baseUrl, mapsUrl, safeJSONParse, safeJSONStringify } from '../common/utils';
+export const ARRAY_DELIMITER = ';';
+const privateKeys = [
+    'filepath'
+];
+export const defaultSuggestionType = 'default';
+const stringValue = (value) => (typeof value === 'undefined' || value === null ? '' : value).toString();
+const nonExpandableArrayDataPath = (key) => key.replace(/\[\d+\]$/, '');
+export const keyToDataPath = (key) => (key === null || key === void 0 ? void 0 : key.length) ? `.${key}` : '';
+export const dataPathToKey = (dataPath, trimArray = false) => trimArray ? nonExpandableArrayDataPath(dataPath.substring(1)) : dataPath.substring(1);
+export const parentKey = (key) => {
+    const keys = (key.startsWith('.') ? key.substring(1) : key).split('.');
+    keys.pop();
+    return keys.join('.');
+};
+/**
+ * Sort properties having errors, type, id, ...properties (simple), and finally the groups
+ *
+ * @param a {INodeProperty}
+ * @param b {INodeProperty}
+ */
+export const sortProperties = (a, b) => {
+    if (isNumber(a.key) && isNumber(b.key)) {
+        return +a.key - +b.key;
+    }
+    if (a.isExpandable) {
+        return b.isExpandable ? a.key.localeCompare(b.key) : 1;
+    }
+    if (b.isExpandable) {
+        return -1;
+    }
+    if (!a.key) {
+        return -1;
+    }
+    const aKey = a.key.replace('@', '');
+    const bKey = b.key.replace('@', '');
+    if (aKey === 'type') {
+        return -1;
+    }
+    if (bKey === 'type') {
+        return 1;
+    }
+    if (aKey === 'id' && bKey !== 'type') {
+        return -1;
+    }
+    if (a.hasError || a.hasWarning) {
+        return -1;
+    }
+    return a.key.localeCompare(b.key);
+};
+const defaultPropertyError = {
+    max: ({ max }) => `should be <= ${max}`,
+    min: ({ min }) => `should be >= ${min}`,
+    pattern: ({ requiredPattern }) => `should match pattern "${requiredPattern}"`,
+    required: (_e, { schemaType }) => schemaType ? `should be set or linked to another ${schemaType}` : undefined
+};
+export const formatPropertyError = (errors, property) => {
+    const key = Object.keys(errors)[0];
+    return key in defaultPropertyError ? formatCustomErrorMessage(defaultPropertyError[key](errors[key], property)) : '';
+};
+export const hasError = value => Array.isArray(value) ? value.some(hasError) : value.hasError;
+export const hasWarning = value => Array.isArray(value) ? value.some(hasWarning) : value.hasWarning;
+const compileSuggestionQueries = (key, allOf) => {
+    const conditions = (allOf || [])
+        .filter(v => { var _c; return (((_c = v.if) === null || _c === void 0 ? void 0 : _c.required) || []).includes(key); })
+        .map(v => { var _c; return (_c = v.then) === null || _c === void 0 ? void 0 : _c.properties[key]; })
+        .map(v => { var _c; return ((_c = v === null || v === void 0 ? void 0 : v.items) === null || _c === void 0 ? void 0 : _c.properties) || (v === null || v === void 0 ? void 0 : v.properties); })
+        .filter(Boolean);
+    return conditions.length ? [{
+            bool: {
+                should: conditions.flatMap(cond => Object.keys(cond).flatMap(k => (cond[k].enum || []).map(v => ({
+                    match: { [k]: v }
+                })))),
+                minimum_should_match: 1
+            }
+        }] : [];
+};
+// default suggest for linking nodes together using the `id` field
+const suggestLinkNodes = (type, fullKey) => {
+    const keys = fullKey.split('.');
+    const key = keys.pop();
+    return key === 'id' && keys.length >= 1 ? { type, isLinkNode: true } : undefined;
+};
+const suggestExistingNode = (type, fullKey) => {
+    const keys = fullKey.split('.');
+    const key = keys.pop();
+    return keys.length >= 1 && ['@id', 'openLCAId'].includes(key) ? { type, isUniqueKey: '@id' } : undefined;
+};
+const defaultNodeTypeSuggestion = (type) => (fullKey) => suggestLinkNodes(type, fullKey) || suggestExistingNode(type, fullKey);
+const termSuggestions = (parent, { allOf }) => ({
+    type: NodeType.Term,
+    queries: [
+        ...compileSuggestionQueries(nonExpandableArrayDataPath(parent), allOf),
+        ...(['country'].includes(parent) ? [matchCountry] : [])
+    ]
+});
+export const formatLinkNodesSuggestions = (nodeMap, type) => (nodeMap[type] || []).map(id => ({ type, id, name: `Link with ${type}: ${id}` }));
+const typeToSuggestion = {
+    [NodeType.Actor]: defaultNodeTypeSuggestion(NodeType.Actor),
+    [NodeType.Cycle]: defaultNodeTypeSuggestion(NodeType.Cycle),
+    [NodeType.ImpactAssessment]: defaultNodeTypeSuggestion(NodeType.ImpactAssessment),
+    [NodeType.Organisation]: defaultNodeTypeSuggestion(NodeType.Organisation),
+    [NodeType.Site]: defaultNodeTypeSuggestion(NodeType.Site),
+    [NodeType.Source]: defaultNodeTypeSuggestion(NodeType.Source),
+    [NodeType.Term]: (fullKey, parentSchema) => {
+        const keys = fullKey.split('.');
+        const key = keys.pop();
+        return ['name'].includes(key) && keys.length >= 1 ?
+            termSuggestions(keys.pop(), parentSchema) :
+            defaultNodeTypeSuggestion(NodeType.Term)(fullKey);
+    },
+    [SchemaType.Bibliography]: (fullKey) => {
+        const keys = fullKey.split('.');
+        const key = keys.pop();
+        const parent = keys.pop();
+        // prevent replacing a top-level source
+        return ['title', 'documentDOI', 'scopus'].includes(key) && parent === 'bibliography' && keys.length >= 1 ? {
+            type: NodeType.Source,
+            parentLevel: 1
+        } : null;
+    },
+    number: (_a, _b, schema) => {
+        const values = schema.const ? [schema.const] : [];
+        return {
+            type: values.length > 0 ? 'select' : defaultSuggestionType,
+            // exclude suggesting SchemaType
+            values
+        };
+    },
+    integer: (_a, _b, schema) => {
+        const values = schema.const ? [schema.const] : [];
+        return {
+            type: values.length > 0 ? 'select' : defaultSuggestionType,
+            // exclude suggesting SchemaType
+            values
+        };
+    },
+    string: (fullKey, _b, schema) => {
+        // exclude suggesting SchemaType
+        const values = schema.const ?
+            [schema.const] :
+            (schema.enum || []).filter(val => !Object.values(SchemaType).includes(val));
+        const key = fullKey.split('.').pop();
+        return {
+            type: values.length > 0 && key !== 'type' ? 'select' : defaultSuggestionType,
+            values
+        };
+    },
+    boolean: (_a) => ({
+        type: 'select',
+        values: ['true', 'false']
+    })
+};
+const enableSuggestions = (parentSchema, type, fullKey, schema) => {
+    const suggestion = type in typeToSuggestion ? typeToSuggestion[type](fullKey, parentSchema) : null;
+    return suggestion !== null ? suggestion : (schema && schema.type in typeToSuggestion ?
+        typeToSuggestion[schema.type](fullKey, parentSchema, schema) :
+        null);
+};
+const formatProperty = (prop) => (Object.assign(Object.assign({ '@type': SchemaType.Property }, prop), { term: Object.assign({ '@type': NodeType.Term }, prop.term) }));
+export const formatSuggestion = (_c) => {
+    var { defaultProperties } = _c, node = __rest(_c, ["defaultProperties"]);
+    return (Object.assign(Object.assign({}, node), (defaultProperties ? { defaultProperties: defaultProperties.map(formatProperty) } : {})));
+};
+export const nodeAvailableProperties = (node, { fullKey, schema, schemaType }) => availableProperties(schema, schemaType, fullKey ? get(node, fullKey, {}) : node, fullKey.length > 0);
+export const isAddPropertyEnabled = (node, schemaType, schema, fullKey = '') => !!schema &&
+    !!Object.keys(nodeAvailableProperties(node, { fullKey, schema })).length &&
+    (!fullKey || nestingTypeEnabled(schemaType));
+const editableKey = (key) => !['type', '@type', 'termType'].includes(key);
+export const propertyId = () => uuidv4();
+const propertyUrl = (node, key) => ['@id', 'name'].includes(key) && linkTypeEnabled(node['@type']) ?
+    {
+        url: `${baseUrl()}/${node['@type'].toLowerCase()}/${node['@id']}`,
+        title: 'Open'
+    } :
+    (node.type === SchemaType.Term && ['name'].includes(key) ? {
+        url: `${baseUrl()}/glossary?query=`,
+        urlParamValue: true,
+        title: 'Search in Glossary'
+    } : undefined);
+const propertyMapsUrl = (node, key, value) => ['type'].includes(key) && [
+    SchemaType.Site.toString(),
+    SchemaType.Organisation.toString()
+].includes(stringValue(value) || node.type) ?
+    {
+        url: mapsUrl({ lat: node.latitude, lng: node.longitude }),
+        title: 'View on maps',
+        icon: 'map'
+    } :
+    undefined;
+const propertyExternalUrl = (node, key, value) => propertyUrl(node, key) ||
+    propertyMapsUrl(node, key, value);
+const arrayPlaceholder = (valueType) => `Type a ${valueType} then press Enter`;
+const defaultPlaceholder = ({ type, examples }, valueType) => (examples === null || examples === void 0 ? void 0 : examples.length) ? (Array.isArray(examples[0]) ? arrayPlaceholder(valueType) : examples[0]) : `Must be of type ${type || valueType}`;
+const schemaPlacholder = (schema, fullKey) => {
+    const [parent, ...keys] = fullKey.split('.');
+    const properties = schema.properties || {};
+    const { examples } = parent in properties ? properties[parent] : { examples: [] };
+    return (examples === null || examples === void 0 ? void 0 : examples.length) && typeof examples[0] === 'object' ? get(examples[0], keys.join('.'), null) : null;
+};
+const propertyPlaceholder = (schema, valueType, fullKey = '', parentSchema) => schema.type === 'array' ?
+    arrayPlaceholder(valueType) : (parentSchema && (fullKey === null || fullKey === void 0 ? void 0 : fullKey.length) ? schemaPlacholder(parentSchema, fullKey) : null) || defaultPlaceholder(schema, valueType);
+const propertyTypeValue = {
+    object: val => safeJSONStringify(val),
+    array: (val, schema) => {
+        const { items } = schema;
+        return '$ref' in items ? val : (Array.isArray(val) ?
+            val.map(value => propertyValue(items, value)).join(ARRAY_DELIMITER) :
+            val);
+    },
+    json: val => val || '',
+    string: val => (`${val}` || '').trim(),
+    number: val => +(`${val}` || '0'),
+    integer: val => +(`${val}` || '0'),
+    boolean: val => (`${val}` || '').toLowerCase() === 'true'
+};
+const propertyValue = (schema, value) => schema.type ? (Array.isArray(schema.type) ?
+    propertyTypeValue[typeof value](value, schema) :
+    propertyTypeValue[schema.type](value, schema)) :
+    safeJSONStringify(value);
+const propertyValueType = (schema, value) => (schema.type ? (Array.isArray(schema.type) ?
+    schema.type[0] :
+    schema.type === 'array' ?
+        propertyValueType(Object.assign(Object.assign({}, schema), { type: [schema.items.type] })) :
+        schema.type) : typeof value);
+const propertyTypeParseValue = {
+    object: val => safeJSONParse(val),
+    array: (val, schema) => {
+        const { items } = schema;
+        return '$ref' in items ? val : (!val || Array.isArray(val) ? val : val.split(ARRAY_DELIMITER).map(value => parseNewValue(items, value)));
+    },
+    json: val => val || '',
+    string: val => (`${val}` || '').trim(),
+    number: val => +(`${val}` || '0'),
+    integer: val => +(`${val}` || '0'),
+    boolean: val => (`${val}` || '').toLowerCase() === 'true'
+};
+/**
+ * Convert value to the final type in the schema.
+ *
+ * @param schema Definition of the value.
+ * @param value
+ * @returns Value in the correct format.
+ */
+export const parseNewValue = (schema, value) => schema.type ? (Array.isArray(schema.type) ?
+    propertyTypeParseValue[typeof value](value, schema) :
+    propertyTypeParseValue[schema.type](value, schema)) : value;
+const isOpenDefault = (schemaType) => [
+    SchemaType.Term
+].includes(schemaType);
+// can the property be seen when the group is closed
+const isKeyClosedVisible = (key) => ['type', 'id', '@type', '@id'].includes(key);
+const isKeyHidden = (key) => ['type', '@type'].includes(key);
+const isKeyRequired = (key, def) => ['type', 'id'].includes(key) || ((def === null || def === void 0 ? void 0 : def.required) || []).includes(key);
+export const propertyError = (errors) => (dataPath, nonExpandableArray = false) => errors.find(error => (error.dataPath === dataPath || (nonExpandableArray && nonExpandableArrayDataPath(error.dataPath) === nonExpandableArrayDataPath(dataPath))) && (dataPath.length > 0 || !isMissingPropertyError(error)));
+const missingPropertyErrors = (node, errors, parent = '') => {
+    const allErrors = errors.filter(error => error.dataPath === keyToDataPath(parent) && isMissingPropertyError(error));
+    // check for node not found errors
+    const missingNode = missingNodeErrors(allErrors);
+    return missingNode.length === 2 ? [{
+            id: propertyId(),
+            schemaType: node.type,
+            suggestions: { type: defaultSuggestionType },
+            key: '',
+            fullKey: parent,
+            value: '',
+            error: {
+                level: 'error',
+                message: missingNodeErrorMessage(node)
+            },
+            hasError: true,
+            properties: [],
+            addPropertyEnabled: false
+        }] : allErrors.map(error => {
+        const { missingProperty } = error.params;
+        const fullKey = parent ? `${parent}.${missingProperty}` : missingProperty;
+        const missingOneOf = isMissingOneOfError(error);
+        return {
+            id: propertyId(),
+            schemaType: node.type,
+            suggestions: { type: defaultSuggestionType },
+            key: missingProperty,
+            fullKey,
+            value: 'Add field to fix',
+            editable: false,
+            error: formatError(error),
+            hasError: missingOneOf ? false : errorHasError(error),
+            hasWarning: missingOneOf || errorHasWarning(error),
+            properties: [],
+            addPropertyEnabled: true
+        };
+    });
+};
+const propertyFromNode = (schemas, errors, nodeSchema, deepEditable, parent = '', node) => (key) => {
+    const value = node[key];
+    const expandable = isExpandable(value);
+    const isArray = Array.isArray(value);
+    const nonExpandableArray = isArray && !expandable;
+    const fullKey = Array.isArray(node) ? `${parent}[${key}]` : [
+        parent,
+        key
+    ].filter(Boolean).join('.');
+    const nodeType = node.type || node['@type'];
+    const schemaType = expandable ? (isArray && value.length ? value[0].type || value[0]['@type'] : value.type || value['@type']) : nodeType;
+    const schema = (schemas && isTypeValid({ type: schemaType }) ? (expandable ? schemas[schemaType] : schemas[schemaType].properties[key]) : null) || {};
+    const isIri = isSchemaIri(schema);
+    const error = propertyError(errors)(keyToDataPath(fullKey), nonExpandableArray);
+    const parentSchema = expandable ? (
+    // TODO: for non-array, should be schema unless last recursion
+    isArray ? schema : nodeSchema) : nodeSchema;
+    const properties = expandable || isIri ?
+        recursiveProperties(schemas, errors, parentSchema, deepEditable, fullKey)(value) : [];
+    const inError = errorHasError(error) || hasError(properties);
+    const inWarning = errorHasWarning(error) || hasWarning(properties);
+    const editable = isTypeNode(node['@type']) || (expandable && isTypeNode(value['@type'])) ?
+        false :
+        (
+        // prevent editing/adding new properties on existing sub-nodes
+        !deepEditable && isTypeNode(schemaType) && (expandable ? value.type !== NodeType.Term : parent && node.type !== NodeType.Term) ?
+            false :
+            // handle IRI
+            (!schemaType && key === '@id') || editableKey(key));
+    const valueType = propertyValueType(schema, value);
+    return {
+        id: propertyId(),
+        schemaType: isIri ? null : schemaType,
+        schema,
+        key,
+        fullKey,
+        value: propertyValue(schema, value),
+        editable: inError || editable,
+        suggestions: enableSuggestions(nodeSchema, node.type, fullKey, schema),
+        addPropertyEnabled: isAddPropertyEnabled(node, schemaType, schema, fullKey),
+        newProperty: {},
+        newError: { level: 'warning' },
+        error: formatError(error),
+        isHidden: parent && isKeyHidden(key),
+        closedVisible: isKeyClosedVisible(key),
+        hasError: inError,
+        hasWarning: inWarning,
+        isRequired: isKeyRequired(key, schemas[nodeType]),
+        isArray,
+        isExpandable: expandable,
+        isOpen: isOpenDefault(schemaType),
+        properties,
+        placeholder: propertyPlaceholder(schema, valueType, fullKey, parentSchema),
+        externalUrl: propertyExternalUrl(node, key, value)
+    };
+};
+export const singleProperty = (schemas, errors, node, fullKey) => {
+    const [_t, ...keys] = fullKey.split('.');
+    const key = keys.pop();
+    const parent = keys.join('.');
+    const parentNode = parent.length ? get(node, parent) : node;
+    const schemaType = typeToSchemaType(parentNode.type || parentNode['@type']);
+    const parentSchema = schemas[schemaType];
+    return propertyFromNode(schemas, errors, parentSchema, true, parent, parentNode)(key);
+};
+export const recursiveProperties = (schemas, errors, nodeSchema, deepEditable, parent = '') => (node) => Object.keys(node)
+    .filter(key => !privateKeys.includes(key))
+    .map(propertyFromNode(schemas, errors, nodeSchema, deepEditable, parent, node))
+    .concat(...missingPropertyErrors(node, errors, parent))
+    .sort(sortProperties);
+const fullKeyParts = (fullKey) => fullKey.split('.').flatMap(val => {
+    if (val.endsWith(']')) {
+        const [key, index] = val.split('[');
+        return [key, index.replace(']', '')];
+    }
+    return val;
+});
+export const updateProperties = ({ properties }, updater) => (properties || []).map(prop => updateProperties(updater(prop), updater));
+export const typeToNewProperty = (schemas, schema, nodeSchema, node, fullKey) => {
+    const key = fullKeyParts(fullKey).pop();
+    const mappings = {
+        object: () => {
+            const { schemaType, properties } = schemaRequiredProperties(schemas, schema);
+            node[key] = node[key] || {};
+            node[key].type = schemaType;
+            // TODO: handle load schemas from http source
+            if (schemaType.startsWith('http')) {
+                return typeToNewProperty(schemas, { type: 'json' }, nodeSchema, node, fullKey);
+            }
+            // TODO: handle nodeSchema should be schema unless last recursion
+            const props = properties
+                .filter(prop => nestingEnabled(schemaType, prop.key) && !!prop.value)
+                .map(v => (Object.assign(Object.assign({}, typeToNewProperty(schemas, v.value, nodeSchema, node[key], `${fullKey}.${v.key}`)), { isRequired: true })));
+            const value = props.reduce((prev, curr) => (Object.assign(Object.assign({}, prev), { [curr.key]: curr.value })), {});
+            return {
+                id: propertyId(),
+                isAdded: true,
+                schema: schemas[schemaType],
+                schemaType,
+                key,
+                fullKey,
+                value,
+                editable: editableKey(key),
+                isHidden: isKeyHidden(key),
+                closedVisible: isKeyClosedVisible(key),
+                suggestions: enableSuggestions(nodeSchema, schemaType, fullKey),
+                properties: props.sort(sortProperties),
+                addPropertyEnabled: isAddPropertyEnabled(node, schemaType, schemas[schemaType], key),
+                newProperty: {},
+                newError: { level: 'warning' },
+                isRequired: isKeyRequired(key, schema),
+                isArray: false,
+                isExpandable: true,
+                isOpen: isOpenDefault(schemaType)
+            };
+        },
+        array: () => {
+            const { items } = schema;
+            // array of string, number and boolean
+            if (items.type) {
+                return mappings.default();
+            }
+            const schemaType = definitionToSchemaType(items);
+            node[key] = node[key] || [];
+            node[key].push({});
+            const property = typeToNewProperty(schemas, items, schemas[schemaType], node[key][0], `${fullKey}[0]`);
+            return {
+                id: propertyId(),
+                isAdded: true,
+                schema,
+                schemaType,
+                key,
+                fullKey,
+                value: [property.value],
+                editable: editableKey(key),
+                isHidden: isKeyHidden(key),
+                closedVisible: isKeyClosedVisible(key),
+                suggestions: undefined,
+                properties: [property],
+                newProperty: {},
+                newError: { level: 'warning' },
+                isArray: true,
+                isExpandable: true,
+                addPropertyEnabled: false
+            };
+        },
+        default: () => {
+            const valueType = propertyValueType(schema);
+            const value = schema.default || schema.const || valueTypeToDefault[valueType];
+            node[key] = value;
+            return {
+                id: propertyId(),
+                isAdded: true,
+                schema,
+                schemaType: node.type,
+                key,
+                fullKey,
+                value: propertyValue(schema, value),
+                editable: editableKey(key),
+                isHidden: isKeyHidden(key),
+                closedVisible: isKeyClosedVisible(key),
+                suggestions: enableSuggestions(nodeSchema, node.type, fullKey, schema),
+                placeholder: propertyPlaceholder(schema, valueType, fullKey, nodeSchema),
+                externalUrl: propertyExternalUrl(node, key, value),
+                properties: [],
+                addPropertyEnabled: false
+            };
+        }
+    };
+    const mapped = !schema.type ? mappings.object : (schema.type in mappings ? mappings[schema.type] : mappings.default);
+    return mapped();
+};
+export const findProperty = (properties, fullKey) => {
+    for (const p of properties) {
+        if (p.fullKey === fullKey) {
+            return p;
+        }
+        const childP = findProperty(p.properties, fullKey);
+        if (childP) {
+            return childP;
+        }
+    }
+    return null;
+};
+export const parentProperty = (properties, property) => {
+    var _c;
+    const allKeys = property.fullKey.split('.');
+    [...new Array(((_c = property.suggestions) === null || _c === void 0 ? void 0 : _c.parentLevel) || 0)].map(() => allKeys.pop());
+    const parentKeys = fullKeyParts(allKeys.join('.'));
+    parentKeys.pop();
+    const parent = parentKeys.reduce((prev, curr, currIndex) => {
+        const prop = prev.find(v => v.key === curr);
+        return currIndex === parentKeys.length - 1 ? (prop || {}) : (prop.properties || []);
+    }, properties);
+    return Array.isArray(parent) ? property : parent;
+};
+export const nestedProperty = ({ properties }, nestedKey) => properties.find(({ key }) => key === nestedKey);
+export const siblingProperty = (properties, property, siblingKey) => {
+    const parent = parentProperty(properties, property);
+    const parentProperties = parent === property ? properties : parent.properties;
+    return parentProperties.find(prop => prop.key === siblingKey);
+};
+export const groupChanged = (properties, key, value) => {
+    try {
+        const parentKeys = fullKeyParts(key);
+        parentKeys.reduce((prev, curr, currIndex) => {
+            if (currIndex === parentKeys.length - 1 && value === null) {
+                return prev.splice(prev.findIndex(v => v.key === curr), 1);
+            }
+            else {
+                const prop = prev.find(v => v.key === curr);
+                prop.changed = true;
+                return prop.properties;
+            }
+        }, properties);
+    }
+    catch (_err) { }
+};
+export const refreshPropertyKeys = (property) => property.properties.map((prop, i) => {
+    prop.fullKey = `${property.fullKey}${property.isArray ? `[${i}]` : `.${prop.key}`}`;
+    prop.key = property.isArray ? `${i}` : prop.key;
+    return refreshPropertyKeys(prop);
+});
+export const calculateCycleDurationEnabled = (properties, property) => {
+    const startDate = siblingProperty(properties, property, 'startDate');
+    const endDate = siblingProperty(properties, property, 'endDate');
+    return !!(startDate === null || startDate === void 0 ? void 0 : startDate.value) && !!(endDate === null || endDate === void 0 ? void 0 : endDate.value);
+};
+export const calculateCycleDuration = (properties, property) => {
+    const startDate = siblingProperty(properties, property, 'startDate');
+    const endDate = siblingProperty(properties, property, 'endDate');
+    return diffInDays(startDate.value, endDate.value);
+};
+export const calculateCycleStartDateEnabled = (properties, property) => {
+    const cycleDuration = siblingProperty(properties, property, 'cycleDuration');
+    const endDate = siblingProperty(properties, property, 'endDate');
+    return !!(cycleDuration === null || cycleDuration === void 0 ? void 0 : cycleDuration.value) && !!(endDate === null || endDate === void 0 ? void 0 : endDate.value);
+};
+export const calculateCycleStartDate = (properties, property) => {
+    const cycleDuration = siblingProperty(properties, property, 'cycleDuration');
+    const endDate = siblingProperty(properties, property, 'endDate');
+    return moment(endDate.value).locale('en-gb').subtract(cycleDuration.value, 'days').format('YYYY-MM-DD');
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"files-form.model.js","sourceRoot":"","sources":["../../../src/files/files-form.model.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable complexity */\nconst get = require('lodash.get');\nimport * as moment from 'moment';\nimport 'moment/locale/en-gb';\nimport { v4 as uuidv4 } from 'uuid';\nimport { diffInDays, isNumber } from '@hestia-earth/utils';\nimport {\n  JSON as HestiaJson, SchemaType, NodeType, isTypeNode, isTypeValid, isExpandable,\n  Site, Organisation, Property, typeToSchemaType\n} from '@hestia-earth/schema';\nimport {\n  definitions, definition, IDefinitionObject, IDefinitionArray, genericType\n} from '@hestia-earth/json-schema';\n\nimport {\n  IValidationError, formatCustomErrorMessage, formatError,\n  missingNodeErrorMessage, isMissingPropertyError, errorHasError, errorHasWarning, validationErrorLevel,\n  missingNodeErrors, isMissingOneOfError\n} from './files-error.model';\nimport {\n  schemaRequiredProperties, valueTypeToDefault, definitionToSchemaType, availableProperties,\n  nestingTypeEnabled, nestingEnabled, linkTypeEnabled, isSchemaIri\n} from '../schema/schema.service';\nimport { matchCountry } from '../search/search.model';\nimport { baseUrl, mapsUrl, safeJSONParse, safeJSONStringify } from '../common/utils';\n\nexport const ARRAY_DELIMITER = ';';\nconst privateKeys = [\n  'filepath'\n];\n\nexport type suggestionType = NodeType | 'select' | 'default';\nexport const defaultSuggestionType: suggestionType = 'default';\n\ninterface INodePropertySuggestion {\n  type?: suggestionType;\n  queries?: any[];\n  values?: string[];\n  parentLevel?: number;\n  isLinkNode?: boolean;\n  isUniqueKey?: string;\n}\n\ninterface INewProperty {\n  name?: string;\n  prop?: definition;\n}\n\nexport interface IErrorProperty {\n  level?: validationErrorLevel;\n  message?: string;\n}\n\nexport interface INodeProperty {\n  /**\n   * Whether or not this property was added by the user\n   */\n  id: string;\n  isAdded?: boolean;\n  schemaType: SchemaType;\n  key: string;\n  fullKey: string;\n  value: any;\n  addPropertyEnabled: boolean;\n  suggestions?: INodePropertySuggestion;\n  schema?: definition;\n  error?: IValidationError;\n  hasError?: boolean;\n  hasWarning?: boolean;\n  editable?: boolean;\n  closedVisible?: boolean;\n  newProperty?: INewProperty;\n  newError?: IErrorProperty;\n  isRequired?: boolean;\n  isHidden?: boolean;\n  isArray?: boolean;\n  isExpandable?: boolean;\n  isOpen?: boolean;\n  properties: INodeProperty[];\n  placeholder?: string;\n  externalUrl?: {\n    url?: string;\n    title: string;\n    // default is external-link-alt\n    icon?: string;\n    urlParamValue?: boolean;\n  };\n  // making changes on the property\n  loading?: boolean;\n  // user made changes to the original value\n  changed?: boolean;\n}\n\nconst stringValue = (value: any) => (typeof value === 'undefined' || value === null ? '' : value).toString();\nconst nonExpandableArrayDataPath = (key: string) => key.replace(/\\[\\d+\\]$/, '');\nexport const keyToDataPath = (key: string) => key?.length ? `.${key}` : '';\nexport const dataPathToKey = (dataPath: string, trimArray = false) =>\n  trimArray ? nonExpandableArrayDataPath(dataPath.substring(1)) : dataPath.substring(1);\nexport const parentKey = (key: string) => {\n  const keys = (key.startsWith('.') ? key.substring(1) : key).split('.');\n  keys.pop();\n  return keys.join('.');\n};\n\n/**\n * Sort properties having errors, type, id, ...properties (simple), and finally the groups\n *\n * @param a {INodeProperty}\n * @param b {INodeProperty}\n */\nexport const sortProperties = (a: INodeProperty, b: INodeProperty) => {\n  if (isNumber(a.key) && isNumber(b.key)) {\n    return +a.key - +b.key;\n  }\n  if (a.isExpandable) {\n    return b.isExpandable ? a.key.localeCompare(b.key) : 1;\n  }\n  if (b.isExpandable) {\n    return -1;\n  }\n  if (!a.key) {\n    return -1;\n  }\n  const aKey = a.key.replace('@', '');\n  const bKey = b.key.replace('@', '');\n  if (aKey === 'type') {\n    return -1;\n  }\n  if (bKey === 'type') {\n    return 1;\n  }\n  if (aKey === 'id' && bKey !== 'type') {\n    return -1;\n  }\n  if (a.hasError || a.hasWarning) {\n    return -1;\n  }\n  return a.key.localeCompare(b.key);\n};\n\nconst defaultPropertyError: {\n  [key: string]: (error: any, property: INodeProperty) => string | undefined;\n} = {\n  max: ({ max }) => `should be <= ${max}`,\n  min: ({ min }) => `should be >= ${min}`,\n  pattern: ({ requiredPattern }) => `should match pattern \"${requiredPattern}\"`,\n  required: (_e, { schemaType }) => schemaType ? `should be set or linked to another ${schemaType}` : undefined\n};\n\nexport const formatPropertyError = (errors: any, property: INodeProperty) => {\n  const key = Object.keys(errors)[0];\n  return key in defaultPropertyError ? formatCustomErrorMessage(defaultPropertyError[key](errors[key], property)) : '';\n};\n\nexport const hasError = value => Array.isArray(value) ? value.some(hasError) : value.hasError;\n\nexport const hasWarning = value => Array.isArray(value) ? value.some(hasWarning) : value.hasWarning;\n\nconst compileSuggestionQueries = (key: string, allOf: any[]) => {\n  const conditions = (allOf || [])\n    .filter(v => (v.if?.required || []).includes(key))\n    .map(v => v.then?.properties[key])\n    .map(v => v?.items?.properties || v?.properties)\n    .filter(Boolean);\n  return conditions.length ? [{\n    bool: {\n      should: conditions.flatMap(cond => Object.keys(cond).flatMap(k => (cond[k].enum || []).map(v => ({\n        match: { [k]: v }\n      })))),\n      minimum_should_match: 1\n    }\n  }] : [];\n};\n\n// default suggest for linking nodes together using the `id` field\nconst suggestLinkNodes = (type: NodeType, fullKey: string): INodePropertySuggestion | undefined => {\n  const keys = fullKey.split('.');\n  const key = keys.pop();\n  return key === 'id' && keys.length >= 1 ? { type, isLinkNode: true } : undefined;\n};\n\nconst suggestExistingNode = (type: NodeType, fullKey: string): INodePropertySuggestion | undefined => {\n  const keys = fullKey.split('.');\n  const key = keys.pop()!;\n  return keys.length >= 1 && ['@id', 'openLCAId'].includes(key) ? { type, isUniqueKey: '@id' } : undefined;\n};\n\nconst defaultNodeTypeSuggestion = (type: NodeType) => (fullKey: string) =>\n  suggestLinkNodes(type, fullKey) || suggestExistingNode(type, fullKey);\n\nconst termSuggestions = (parent: string, { allOf }: IDefinitionObject) => ({\n  type: NodeType.Term,\n  queries: [\n    ...compileSuggestionQueries(nonExpandableArrayDataPath(parent), allOf!),\n    ...(['country'].includes(parent) ? [matchCountry] : [])\n  ]\n});\n\nexport const formatLinkNodesSuggestions = (nodeMap: { [type in NodeType]?: string[] }, type: NodeType) =>\n  (nodeMap[type] || []).map(id => ({ type, id, name: `Link with ${type}: ${id}` }));\n\nconst typeToSuggestion: {\n  [type in SchemaType|NodeType|genericType|'integer']?: (\n    fullKey: string, parentSchema?: definition, schema?: definition\n  ) => INodePropertySuggestion|any;\n} = {\n  [NodeType.Actor]: defaultNodeTypeSuggestion(NodeType.Actor),\n  [NodeType.Cycle]: defaultNodeTypeSuggestion(NodeType.Cycle),\n  [NodeType.ImpactAssessment]: defaultNodeTypeSuggestion(NodeType.ImpactAssessment),\n  [NodeType.Organisation]: defaultNodeTypeSuggestion(NodeType.Organisation),\n  [NodeType.Site]: defaultNodeTypeSuggestion(NodeType.Site),\n  [NodeType.Source]: defaultNodeTypeSuggestion(NodeType.Source),\n  [NodeType.Term]: (fullKey, parentSchema) => {\n    const keys = fullKey.split('.');\n    const key = keys.pop()!;\n    return ['name'].includes(key) && keys.length >= 1 ?\n      termSuggestions(keys.pop()!, parentSchema as IDefinitionObject) :\n      defaultNodeTypeSuggestion(NodeType.Term)(fullKey);\n  },\n  [SchemaType.Bibliography]: (fullKey) => {\n    const keys = fullKey.split('.');\n    const key = keys.pop()!;\n    const parent = keys.pop()!;\n    // prevent replacing a top-level source\n    return ['title', 'documentDOI', 'scopus'].includes(key) && parent === 'bibliography' && keys.length >= 1 ? {\n      type: NodeType.Source,\n      parentLevel: 1\n    } : null;\n  },\n  number: (_a, _b, schema) => {\n    const values = (schema as any).const ? [(schema as any).const] : [];\n    return {\n      type: values.length > 0 ? 'select' : defaultSuggestionType,\n      // exclude suggesting SchemaType\n      values\n    };\n  },\n  integer: (_a, _b, schema) => {\n    const values = (schema as any).const ? [(schema as any).const] : [];\n    return {\n      type: values.length > 0 ? 'select' : defaultSuggestionType,\n      // exclude suggesting SchemaType\n      values\n    };\n  },\n  string: (fullKey, _b, schema) => {\n    // exclude suggesting SchemaType\n    const values = (schema as any).const ?\n      [(schema as any).const] :\n      ((schema as any).enum || []).filter(val => !Object.values(SchemaType).includes(val));\n    const key = fullKey.split('.').pop();\n    return {\n      type: values.length > 0 && key !== 'type' ? 'select' : defaultSuggestionType,\n      values\n    };\n  },\n  boolean: (_a) => ({\n    type: 'select',\n    values: ['true', 'false']\n  })\n};\n\nconst enableSuggestions = (\n  parentSchema: definition, type: SchemaType | NodeType | genericType, fullKey: string, schema?: definition\n) => {\n  const suggestion = type in typeToSuggestion ? typeToSuggestion[type]!(fullKey, parentSchema) : null;\n  return suggestion !== null ? suggestion : (\n    schema && schema.type as genericType in typeToSuggestion ?\n      typeToSuggestion[schema.type as genericType]!(fullKey, parentSchema, schema) :\n      null\n  );\n};\n\nconst formatProperty = (prop: Property) => ({\n  '@type': SchemaType.Property,\n  ...prop,\n  term: {\n    '@type': NodeType.Term,\n    ...prop.term\n  }\n});\n\nexport const formatSuggestion = ({ defaultProperties, ...node }: any) => ({\n  ...node,\n  ...(defaultProperties ? { defaultProperties: defaultProperties.map(formatProperty) } : {})\n});\n\nexport const nodeAvailableProperties = (\n  node: HestiaJson<SchemaType>, { fullKey, schema, schemaType }: Partial<INodeProperty>\n) => availableProperties(schema!, schemaType!, fullKey ? get(node, fullKey, {}) : node, fullKey!.length > 0);\n\nexport const isAddPropertyEnabled = (\n  node: HestiaJson<SchemaType>, schemaType: SchemaType, schema: definition, fullKey = ''\n) => !!schema &&\n  !!Object.keys(nodeAvailableProperties(node, { fullKey, schema })).length &&\n  (!fullKey || nestingTypeEnabled(schemaType));\n\nconst editableKey = (key: string) => !['type', '@type', 'termType'].includes(key);\n\nexport const propertyId = () => uuidv4();\n\nconst propertyUrl = (node: HestiaJson<SchemaType>, key: string) =>\n  ['@id', 'name'].includes(key) && linkTypeEnabled(node['@type']) ?\n    {\n      url: `${baseUrl()}/${node['@type'].toLowerCase()}/${node['@id']}`,\n      title: 'Open'\n    } :\n    (\n      node.type === SchemaType.Term && ['name'].includes(key) ? {\n        url: `${baseUrl()}/glossary?query=`,\n        urlParamValue: true,\n        title: 'Search in Glossary'\n      } : undefined\n    );\n\nconst propertyMapsUrl = (node: Site | Organisation, key: string, value) =>\n  ['type'].includes(key) && [\n    SchemaType.Site.toString(),\n    SchemaType.Organisation.toString()\n  ].includes(stringValue(value) || node.type) ?\n    {\n      url: mapsUrl({ lat: node.latitude, lng: node.longitude }),\n      title: 'View on maps',\n      icon: 'map'\n    } :\n    undefined;\n\nconst propertyExternalUrl = (node: HestiaJson<SchemaType>, key: string, value: any) =>\n  propertyUrl(node, key) ||\n  propertyMapsUrl(node as any, key, value);\n\nconst arrayPlaceholder = (valueType: genericType) => `Type a ${valueType} then press Enter`;\n\nconst defaultPlaceholder = ({ type, examples }: any, valueType: genericType) => examples?.length ? (\n  Array.isArray(examples[0]) ? arrayPlaceholder(valueType) : examples[0]\n) : `Must be of type ${type || valueType}`;\n\nconst schemaPlacholder = (schema: any, fullKey: string) => {\n  const [parent, ...keys] = fullKey.split('.');\n  const properties = schema.properties || {};\n  const { examples } = parent in properties ? properties[parent] : { examples: [] };\n  return examples?.length && typeof examples[0] === 'object' ? get(examples[0], keys.join('.'), null): null;\n};\n\nconst propertyPlaceholder = (schema: any, valueType: genericType, fullKey = '', parentSchema?: any) =>\n  schema.type === 'array' ?\n    arrayPlaceholder(valueType) : (\n      parentSchema && fullKey?.length ? schemaPlacholder(parentSchema, fullKey) : null\n    ) || defaultPlaceholder(schema, valueType);\n\nconst propertyTypeValue: {\n  [type: string]: (value: any, schema: definition) => any;\n} = {\n  object: val => safeJSONStringify(val),\n  array: (val, schema) => {\n    const { items } = schema as IDefinitionArray;\n    return '$ref' in items ? val : (\n      Array.isArray(val) ?\n        val.map(value => propertyValue(items, value)).join(ARRAY_DELIMITER) :\n        val\n    );\n  },\n  json: val => val || '',\n  string: val => (`${val}` || '').trim(),\n  number: val => +(`${val}` || '0'),\n  integer: val => +(`${val}` || '0'),\n  boolean: val => (`${val}` || '').toLowerCase() === 'true'\n};\n\nconst propertyValue = (schema: definition, value: any) =>\n  schema.type ? (\n    Array.isArray(schema.type) ?\n      propertyTypeValue[typeof value](value, schema) :\n      propertyTypeValue[schema.type as string](value, schema)\n  ) :\n  safeJSONStringify(value);\n\nconst propertyValueType = (schema: definition, value?: any) =>\n  (schema.type ? (\n    Array.isArray(schema.type) ?\n      schema.type[0] :\n      schema.type === 'array' ?\n        propertyValueType({ ...schema, type: [schema.items.type as genericType] }) :\n        schema.type\n  ) : typeof value) as genericType;\n\nconst propertyTypeParseValue: {\n  [type: string]: (value: any, schema: definition) => any;\n} = {\n  object: val => safeJSONParse(val),\n  array: (val, schema) => {\n    const { items } = schema as IDefinitionArray;\n    return '$ref' in items ? val : (\n      !val || Array.isArray(val) ? val : val.split(ARRAY_DELIMITER).map(value => parseNewValue(items, value))\n    );\n  },\n  json: val => val || '',\n  string: val => (`${val}` || '').trim(),\n  number: val => +(`${val}` || '0'),\n  integer: val => +(`${val}` || '0'),\n  boolean: val => (`${val}` || '').toLowerCase() === 'true'\n};\n\n/**\n * Convert value to the final type in the schema.\n *\n * @param schema Definition of the value.\n * @param value\n * @returns Value in the correct format.\n */\nexport const parseNewValue = (schema: definition, value: any) =>\n  schema.type ? (\n    Array.isArray(schema.type) ?\n      propertyTypeParseValue[typeof value](value, schema) :\n      propertyTypeParseValue[schema.type as string](value, schema)\n  ) : value;\n\nconst isOpenDefault = (schemaType: SchemaType) => [\n  SchemaType.Term\n].includes(schemaType);\n\n// can the property be seen when the group is closed\nconst isKeyClosedVisible = (key: string) => ['type', 'id', '@type', '@id'].includes(key);\n\nconst isKeyHidden = (key: string) => ['type', '@type'].includes(key);\n\nconst isKeyRequired = (key: string, def?: IDefinitionObject) =>\n  ['type', 'id'].includes(key) || (def?.required || []).includes(key);\n\nexport const propertyError = (errors: IValidationError[]) => (dataPath: string, nonExpandableArray = false) =>\n  errors.find(error =>\n    (\n      error.dataPath === dataPath || (\n        nonExpandableArray && nonExpandableArrayDataPath(error.dataPath!) === nonExpandableArrayDataPath(dataPath)\n      )\n    ) && (dataPath.length > 0 || !isMissingPropertyError(error))\n  );\n\nconst missingPropertyErrors = (\n  node: HestiaJson<SchemaType>, errors: IValidationError[], parent = ''\n): INodeProperty[] => {\n  const allErrors = errors.filter(error =>\n    error.dataPath === keyToDataPath(parent) && isMissingPropertyError(error)\n  );\n  // check for node not found errors\n  const missingNode = missingNodeErrors(allErrors);\n  return missingNode.length === 2 ? [{\n    id: propertyId(),\n    schemaType: node.type,\n    suggestions: { type: defaultSuggestionType },\n    key: '',\n    fullKey: parent,\n    value: '',\n    error: {\n      level: 'error',\n      message: missingNodeErrorMessage(node)\n    },\n    hasError: true,\n    properties: [],\n    addPropertyEnabled: false\n  }] : allErrors.map(error => {\n    const { missingProperty } = error.params!;\n    const fullKey = parent ? `${parent}.${missingProperty}` : missingProperty;\n    const missingOneOf = isMissingOneOfError(error);\n    return {\n      id: propertyId(),\n      schemaType: node.type,\n      suggestions: { type: defaultSuggestionType },\n      key: missingProperty,\n      fullKey,\n      value: 'Add field to fix',\n      editable: false,\n      error: formatError(error),\n      hasError: missingOneOf ? false : errorHasError(error),\n      hasWarning: missingOneOf || errorHasWarning(error),\n      properties: [],\n      addPropertyEnabled: true\n    };\n  });\n};\n\nconst propertyFromNode = (\n  schemas: definitions, errors: IValidationError[], nodeSchema: definition, deepEditable: boolean, parent = '', node: any\n) => (key: string) => {\n  const value = node[key];\n  const expandable = isExpandable(value);\n  const isArray = Array.isArray(value);\n  const nonExpandableArray = isArray && !expandable;\n  const fullKey = Array.isArray(node) ? `${parent}[${key}]` : [\n    parent,\n    key\n  ].filter(Boolean).join('.');\n  const nodeType = node.type || node['@type'];\n  const schemaType = expandable ? (\n    isArray && value.length ? value[0].type || value[0]['@type'] : value.type || value['@type']\n  ) : nodeType;\n  const schema = (schemas && isTypeValid({ type: schemaType }) ? (\n    expandable ? schemas[schemaType] : schemas[schemaType].properties[key]\n  ) : null) || {};\n  const isIri = isSchemaIri(schema);\n  const error = propertyError(errors)(keyToDataPath(fullKey), nonExpandableArray);\n  const parentSchema = expandable ? (\n    // TODO: for non-array, should be schema unless last recursion\n    isArray ? schema : nodeSchema\n  ) : nodeSchema;\n  const properties = expandable || isIri ?\n    recursiveProperties(schemas, errors, parentSchema, deepEditable, fullKey)(value) : [];\n  const inError = errorHasError(error) || hasError(properties);\n  const inWarning = errorHasWarning(error) || hasWarning(properties);\n  const editable = isTypeNode(node['@type']) || (expandable && isTypeNode(value['@type'])) ?\n    false :\n    (\n      // prevent editing/adding new properties on existing sub-nodes\n      !deepEditable && isTypeNode(schemaType) && (\n        expandable ? value.type !== NodeType.Term : parent && node.type !== NodeType.Term\n      ) ?\n        false :\n        // handle IRI\n        (!schemaType && key === '@id') || editableKey(key)\n    );\n  const valueType = propertyValueType(schema, value);\n  return {\n    id: propertyId(),\n    schemaType: isIri ? null : schemaType,\n    schema,\n    key,\n    fullKey,\n    value: propertyValue(schema, value),\n    editable: inError || editable,\n    suggestions: enableSuggestions(nodeSchema, node.type, fullKey, schema),\n    addPropertyEnabled: isAddPropertyEnabled(node, schemaType, schema, fullKey),\n    newProperty: {},\n    newError: { level: 'warning' },\n    error: formatError(error),\n    isHidden: parent && isKeyHidden(key),\n    closedVisible: isKeyClosedVisible(key),\n    hasError: inError,\n    hasWarning: inWarning,\n    isRequired: isKeyRequired(key, schemas[nodeType]),\n    isArray,\n    isExpandable: expandable,\n    isOpen: isOpenDefault(schemaType),\n    properties,\n    placeholder: propertyPlaceholder(schema, valueType, fullKey, parentSchema),\n    externalUrl: propertyExternalUrl(node, key, value)\n  } as INodeProperty;\n};\n\nexport const singleProperty = (schemas: definitions, errors: IValidationError[], node: any, fullKey: string) => {\n  const [_t, ...keys] = fullKey.split('.');\n  const key = keys.pop()!;\n  const parent = keys.join('.');\n  const parentNode = parent.length ? get(node, parent) : node;\n  const schemaType = typeToSchemaType(parentNode.type || parentNode['@type']);\n  const parentSchema = schemas[schemaType];\n  return propertyFromNode(schemas, errors, parentSchema, true, parent, parentNode)(key);\n};\n\nexport const recursiveProperties = (\n  schemas: definitions, errors: IValidationError[], nodeSchema: definition, deepEditable: boolean, parent = ''\n) => (node: any): INodeProperty[] =>\n  Object.keys(node)\n    .filter(key => !privateKeys.includes(key))\n    .map(propertyFromNode(schemas, errors, nodeSchema, deepEditable, parent, node))\n    .concat(...missingPropertyErrors(node, errors, parent))\n    .sort(sortProperties);\n\nconst fullKeyParts = (fullKey: string) => fullKey.split('.').flatMap(val => {\n  if (val.endsWith(']')) {\n    const [key, index] = val.split('[');\n    return [key, index.replace(']', '')];\n  }\n  return val;\n});\n\nexport const updateProperties = ({ properties }: Partial<INodeProperty>, updater: (prop: INodeProperty) => INodeProperty) =>\n  (properties || []).map(prop => updateProperties(updater(prop), updater));\n\nexport const typeToNewProperty = (\n  schemas: definitions, schema: definition, nodeSchema: definition, node: any, fullKey: string\n): INodeProperty => {\n  const key = fullKeyParts(fullKey).pop()!;\n  const mappings: {\n    [key: string]: () => INodeProperty;\n  } = {\n    object: () => {\n      const { schemaType, properties } = schemaRequiredProperties(schemas, schema as IDefinitionObject);\n      node[key] = node[key] || {};\n      node[key].type = schemaType;\n      // TODO: handle load schemas from http source\n      if (schemaType.startsWith('http')) {\n        return typeToNewProperty(schemas, { type: 'json' } as any, nodeSchema, node, fullKey);\n      }\n      // TODO: handle nodeSchema should be schema unless last recursion\n      const props = properties\n        .filter(prop => nestingEnabled(schemaType, prop.key) && !!prop.value)\n        .map(\n          v => ({\n            ...typeToNewProperty(schemas, v.value, nodeSchema, node[key], `${fullKey}.${v.key}`),\n            isRequired: true\n          })\n        );\n      const value = props.reduce((prev, curr) => ({ ...prev, [curr.key]: curr.value }), {});\n      return {\n        id: propertyId(),\n        isAdded: true,\n        schema: schemas[schemaType],\n        schemaType,\n        key,\n        fullKey,\n        value,\n        editable: editableKey(key),\n        isHidden: isKeyHidden(key),\n        closedVisible: isKeyClosedVisible(key),\n        suggestions: enableSuggestions(nodeSchema, schemaType, fullKey),\n        properties: props.sort(sortProperties),\n        addPropertyEnabled: isAddPropertyEnabled(node, schemaType, schemas[schemaType], key),\n        newProperty: {},\n        newError: { level: 'warning' },\n        isRequired: isKeyRequired(key, schema as any),\n        isArray: false,\n        isExpandable: true,\n        isOpen: isOpenDefault(schemaType)\n      };\n    },\n    array: () => {\n      const { items } = schema as IDefinitionArray;\n      // array of string, number and boolean\n      if (items.type) {\n        return mappings.default();\n      }\n      const schemaType = definitionToSchemaType(items as IDefinitionObject);\n      node[key] = node[key] || [];\n      node[key].push({ });\n      const property = typeToNewProperty(schemas, items, schemas[schemaType], node[key][0], `${fullKey}[0]`);\n      return {\n        id: propertyId(),\n        isAdded: true,\n        schema,\n        schemaType,\n        key,\n        fullKey,\n        value: [property.value],\n        editable: editableKey(key),\n        isHidden: isKeyHidden(key),\n        closedVisible: isKeyClosedVisible(key),\n        suggestions: undefined,\n        properties: [property],\n        newProperty: {},\n        newError: { level: 'warning' },\n        isArray: true,\n        isExpandable: true,\n        addPropertyEnabled: false\n      };\n    },\n    default: () => {\n      const valueType = propertyValueType(schema);\n      const value = schema.default || (schema as any).const || valueTypeToDefault[valueType];\n      node[key] = value;\n      return {\n        id: propertyId(),\n        isAdded: true,\n        schema,\n        schemaType: node.type,\n        key,\n        fullKey,\n        value: propertyValue(schema, value),\n        editable: editableKey(key),\n        isHidden: isKeyHidden(key),\n        closedVisible: isKeyClosedVisible(key),\n        suggestions: enableSuggestions(nodeSchema, node.type, fullKey, schema),\n        placeholder: propertyPlaceholder(schema, valueType, fullKey, nodeSchema),\n        externalUrl: propertyExternalUrl(node, key, value),\n        properties: [],\n        addPropertyEnabled: false\n      };\n    }\n  };\n  const mapped = !schema.type ? mappings.object : (\n    schema.type as string in mappings ? mappings[schema.type as string] : mappings.default\n  );\n  return mapped();\n};\n\nexport const findProperty = (properties: INodeProperty[], fullKey: string) => {\n  for (const p of properties) {\n    if (p.fullKey === fullKey) {\n      return p;\n    }\n    const childP = findProperty(p.properties, fullKey);\n    if (childP) {\n      return childP;\n    }\n  }\n  return null;\n};\n\nexport const parentProperty = (properties: INodeProperty[], property: INodeProperty) => {\n  const allKeys = property.fullKey.split('.');\n  [...new Array(property.suggestions?.parentLevel || 0)].map(() => allKeys.pop());\n  const parentKeys = fullKeyParts(allKeys.join('.'));\n  parentKeys.pop();\n  const parent = (parentKeys.reduce((prev, curr, currIndex): any => {\n    const prop = prev.find(v => v.key === curr);\n    return currIndex === parentKeys.length - 1 ? (prop || {} as INodeProperty) : (prop!.properties || []);\n  }, properties) as any) as INodeProperty;\n  return Array.isArray(parent) ? property : parent;\n};\n\nexport const nestedProperty = ({ properties }: INodeProperty, nestedKey: string) =>\n  properties.find(({ key }) => key === nestedKey);\n\nexport const siblingProperty = (properties: INodeProperty[], property: INodeProperty, siblingKey: string) => {\n  const parent = parentProperty(properties, property);\n  const parentProperties = parent === property ? properties : parent.properties;\n  return parentProperties.find(prop => prop.key === siblingKey);\n};\n\nexport const groupChanged = (properties: INodeProperty[], key: string, value?: any) => {\n  try {\n    const parentKeys = fullKeyParts(key);\n    parentKeys.reduce((prev, curr, currIndex) => {\n      if (currIndex === parentKeys.length - 1 && value === null) {\n        return prev.splice(prev.findIndex(v => v.key === curr), 1);\n      }\n      else {\n        const prop = prev.find(v => v.key === curr)!;\n        prop.changed = true;\n        return prop.properties;\n      }\n    }, properties);\n  }\n  catch (_err) {}\n};\n\nexport const refreshPropertyKeys = (property: INodeProperty) =>\n  property.properties.map((prop, i) => {\n    prop.fullKey = `${property.fullKey}${property.isArray ? `[${i}]` : `.${prop.key}`}`;\n    prop.key = property.isArray ? `${i}` : prop.key;\n    return refreshPropertyKeys(prop);\n  });\n\nexport const calculateCycleDurationEnabled = (properties: INodeProperty[], property: INodeProperty) => {\n  const startDate = siblingProperty(properties, property, 'startDate');\n  const endDate = siblingProperty(properties, property, 'endDate');\n  return !!startDate?.value && !!endDate?.value;\n};\n\nexport const calculateCycleDuration = (properties: INodeProperty[], property: INodeProperty) => {\n  const startDate = siblingProperty(properties, property, 'startDate')!;\n  const endDate = siblingProperty(properties, property, 'endDate')!;\n  return diffInDays(startDate.value, endDate.value);\n};\n\nexport const calculateCycleStartDateEnabled = (properties: INodeProperty[], property: INodeProperty) => {\n  const cycleDuration = siblingProperty(properties, property, 'cycleDuration');\n  const endDate = siblingProperty(properties, property, 'endDate');\n  return !!cycleDuration?.value && !!endDate?.value;\n};\n\nexport const calculateCycleStartDate = (properties: INodeProperty[], property: INodeProperty) => {\n  const cycleDuration = siblingProperty(properties, property, 'cycleDuration')!;\n  const endDate = siblingProperty(properties, property, 'endDate')!;\n  return moment(endDate.value).locale('en-gb').subtract(cycleDuration.value, 'days').format('YYYY-MM-DD');\n};\n"]}