@ng-formworks/core 16.3.0 → 17.3.0

package/esm2022/lib/shared/merge-schemas.function.mjs

@@ -1,345 +1,345 @@
-import isEqual from 'lodash/isEqual';
-import { isArray, isEmpty, isNumber, isObject, isString } from './validator.functions';
-import { hasOwn, uniqueItems, commonItems } from './utility.functions';
-/**
- * 'mergeSchemas' function
- *
- * Merges multiple JSON schemas into a single schema with combined rules.
- *
- * If able to logically merge properties from all schemas,
- * returns a single schema object containing all merged properties.
- *
- * Example: ({ a: b, max: 1 }, { c: d, max: 2 }) => { a: b, c: d, max: 1 }
- *
- * If unable to logically merge, returns an allOf schema object containing
- * an array of the original schemas;
- *
- * Example: ({ a: b }, { a: d }) => { allOf: [ { a: b }, { a: d } ] }
- *
- * //   schemas - one or more input schemas
- * //  - merged schema
- */
-export function mergeSchemas(...schemas) {
-    schemas = schemas.filter(schema => !isEmpty(schema));
-    if (schemas.some(schema => !isObject(schema))) {
-        return null;
-    }
-    const combinedSchema = {};
-    for (const schema of schemas) {
-        for (const key of Object.keys(schema)) {
-            const combinedValue = combinedSchema[key];
-            const schemaValue = schema[key];
-            if (!hasOwn(combinedSchema, key) || isEqual(combinedValue, schemaValue)) {
-                combinedSchema[key] = schemaValue;
-            }
-            else {
-                switch (key) {
-                    case 'allOf':
-                        // Combine all items from both arrays
-                        if (isArray(combinedValue) && isArray(schemaValue)) {
-                            combinedSchema.allOf = mergeSchemas(...combinedValue, ...schemaValue);
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'additionalItems':
-                    case 'additionalProperties':
-                    case 'contains':
-                    case 'propertyNames':
-                        // Merge schema objects
-                        if (isObject(combinedValue) && isObject(schemaValue)) {
-                            combinedSchema[key] = mergeSchemas(combinedValue, schemaValue);
-                            // additionalProperties == false in any schema overrides all other values
-                        }
-                        else if (key === 'additionalProperties' &&
-                            (combinedValue === false || schemaValue === false)) {
-                            combinedSchema.combinedSchema = false;
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'anyOf':
-                    case 'oneOf':
-                    case 'enum':
-                        // Keep only items that appear in both arrays
-                        if (isArray(combinedValue) && isArray(schemaValue)) {
-                            combinedSchema[key] = combinedValue.filter(item1 => schemaValue.findIndex(item2 => isEqual(item1, item2)) > -1);
-                            if (!combinedSchema[key].length) {
-                                return { allOf: [...schemas] };
-                            }
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'definitions':
-                        // Combine keys from both objects
-                        if (isObject(combinedValue) && isObject(schemaValue)) {
-                            const combinedObject = { ...combinedValue };
-                            for (const subKey of Object.keys(schemaValue)) {
-                                if (!hasOwn(combinedObject, subKey) ||
-                                    isEqual(combinedObject[subKey], schemaValue[subKey])) {
-                                    combinedObject[subKey] = schemaValue[subKey];
-                                    // Don't combine matching keys with different values
-                                }
-                                else {
-                                    return { allOf: [...schemas] };
-                                }
-                            }
-                            combinedSchema.definitions = combinedObject;
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'dependencies':
-                        // Combine all keys from both objects
-                        // and merge schemas on matching keys,
-                        // converting from arrays to objects if necessary
-                        if (isObject(combinedValue) && isObject(schemaValue)) {
-                            const combinedObject = { ...combinedValue };
-                            for (const subKey of Object.keys(schemaValue)) {
-                                if (!hasOwn(combinedObject, subKey) ||
-                                    isEqual(combinedObject[subKey], schemaValue[subKey])) {
-                                    combinedObject[subKey] = schemaValue[subKey];
-                                    // If both keys are arrays, include all items from both arrays,
-                                    // excluding duplicates
-                                }
-                                else if (isArray(schemaValue[subKey]) && isArray(combinedObject[subKey])) {
-                                    combinedObject[subKey] =
-                                        uniqueItems(...combinedObject[subKey], ...schemaValue[subKey]);
-                                    // If either key is an object, merge the schemas
-                                }
-                                else if ((isArray(schemaValue[subKey]) || isObject(schemaValue[subKey])) &&
-                                    (isArray(combinedObject[subKey]) || isObject(combinedObject[subKey]))) {
-                                    // If either key is an array, convert it to an object first
-                                    const required = isArray(combinedSchema.required) ?
-                                        combinedSchema.required : [];
-                                    const combinedDependency = isArray(combinedObject[subKey]) ?
-                                        { required: uniqueItems(...required, combinedObject[subKey]) } :
-                                        combinedObject[subKey];
-                                    const schemaDependency = isArray(schemaValue[subKey]) ?
-                                        { required: uniqueItems(...required, schemaValue[subKey]) } :
-                                        schemaValue[subKey];
-                                    combinedObject[subKey] =
-                                        mergeSchemas(combinedDependency, schemaDependency);
-                                }
-                                else {
-                                    return { allOf: [...schemas] };
-                                }
-                            }
-                            combinedSchema.dependencies = combinedObject;
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'items':
-                        // If arrays, keep only items that appear in both arrays
-                        if (isArray(combinedValue) && isArray(schemaValue)) {
-                            combinedSchema.items = combinedValue.filter(item1 => schemaValue.findIndex(item2 => isEqual(item1, item2)) > -1);
-                            if (!combinedSchema.items.length) {
-                                return { allOf: [...schemas] };
-                            }
-                            // If both keys are objects, merge them
-                        }
-                        else if (isObject(combinedValue) && isObject(schemaValue)) {
-                            combinedSchema.items = mergeSchemas(combinedValue, schemaValue);
-                            // If object + array, combine object with each array item
-                        }
-                        else if (isArray(combinedValue) && isObject(schemaValue)) {
-                            combinedSchema.items =
-                                combinedValue.map(item => mergeSchemas(item, schemaValue));
-                        }
-                        else if (isObject(combinedValue) && isArray(schemaValue)) {
-                            combinedSchema.items =
-                                schemaValue.map(item => mergeSchemas(item, combinedValue));
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'multipleOf':
-                        // TODO: Adjust to correctly handle decimal values
-                        // If numbers, set to least common multiple
-                        if (isNumber(combinedValue) && isNumber(schemaValue)) {
-                            const gcd = (x, y) => !y ? x : gcd(y, x % y);
-                            const lcm = (x, y) => (x * y) / gcd(x, y);
-                            combinedSchema.multipleOf = lcm(combinedValue, schemaValue);
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'maximum':
-                    case 'exclusiveMaximum':
-                    case 'maxLength':
-                    case 'maxItems':
-                    case 'maxProperties':
-                        // If numbers, set to lowest value
-                        if (isNumber(combinedValue) && isNumber(schemaValue)) {
-                            combinedSchema[key] = Math.min(combinedValue, schemaValue);
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'minimum':
-                    case 'exclusiveMinimum':
-                    case 'minLength':
-                    case 'minItems':
-                    case 'minProperties':
-                        // If numbers, set to highest value
-                        if (isNumber(combinedValue) && isNumber(schemaValue)) {
-                            combinedSchema[key] = Math.max(combinedValue, schemaValue);
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'not':
-                        // Combine not values into anyOf array
-                        if (isObject(combinedValue) && isObject(schemaValue)) {
-                            const notAnyOf = [combinedValue, schemaValue]
-                                .reduce((notAnyOfArray, notSchema) => isArray(notSchema.anyOf) &&
-                                Object.keys(notSchema).length === 1 ?
-                                [...notAnyOfArray, ...notSchema.anyOf] :
-                                [...notAnyOfArray, notSchema], []);
-                            // TODO: Remove duplicate items from array
-                            combinedSchema.not = { anyOf: notAnyOf };
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'patternProperties':
-                        // Combine all keys from both objects
-                        // and merge schemas on matching keys
-                        if (isObject(combinedValue) && isObject(schemaValue)) {
-                            const combinedObject = { ...combinedValue };
-                            for (const subKey of Object.keys(schemaValue)) {
-                                if (!hasOwn(combinedObject, subKey) ||
-                                    isEqual(combinedObject[subKey], schemaValue[subKey])) {
-                                    combinedObject[subKey] = schemaValue[subKey];
-                                    // If both keys are objects, merge them
-                                }
-                                else if (isObject(schemaValue[subKey]) && isObject(combinedObject[subKey])) {
-                                    combinedObject[subKey] =
-                                        mergeSchemas(combinedObject[subKey], schemaValue[subKey]);
-                                }
-                                else {
-                                    return { allOf: [...schemas] };
-                                }
-                            }
-                            combinedSchema.patternProperties = combinedObject;
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'properties':
-                        // Combine all keys from both objects
-                        // unless additionalProperties === false
-                        // and merge schemas on matching keys
-                        if (isObject(combinedValue) && isObject(schemaValue)) {
-                            const combinedObject = { ...combinedValue };
-                            // If new schema has additionalProperties,
-                            // merge or remove non-matching property keys in combined schema
-                            if (hasOwn(schemaValue, 'additionalProperties')) {
-                                Object.keys(combinedValue)
-                                    .filter(combinedKey => !Object.keys(schemaValue).includes(combinedKey))
-                                    .forEach(nonMatchingKey => {
-                                    if (schemaValue.additionalProperties === false) {
-                                        delete combinedObject[nonMatchingKey];
-                                    }
-                                    else if (isObject(schemaValue.additionalProperties)) {
-                                        combinedObject[nonMatchingKey] = mergeSchemas(combinedObject[nonMatchingKey], schemaValue.additionalProperties);
-                                    }
-                                });
-                            }
-                            for (const subKey of Object.keys(schemaValue)) {
-                                if (isEqual(combinedObject[subKey], schemaValue[subKey]) || (!hasOwn(combinedObject, subKey) &&
-                                    !hasOwn(combinedObject, 'additionalProperties'))) {
-                                    combinedObject[subKey] = schemaValue[subKey];
-                                    // If combined schema has additionalProperties,
-                                    // merge or ignore non-matching property keys in new schema
-                                }
-                                else if (!hasOwn(combinedObject, subKey) &&
-                                    hasOwn(combinedObject, 'additionalProperties')) {
-                                    // If combinedObject.additionalProperties === false,
-                                    // do nothing (don't set key)
-                                    // If additionalProperties is object, merge with new key
-                                    if (isObject(combinedObject.additionalProperties)) {
-                                        combinedObject[subKey] = mergeSchemas(combinedObject.additionalProperties, schemaValue[subKey]);
-                                    }
-                                    // If both keys are objects, merge them
-                                }
-                                else if (isObject(schemaValue[subKey]) &&
-                                    isObject(combinedObject[subKey])) {
-                                    combinedObject[subKey] =
-                                        mergeSchemas(combinedObject[subKey], schemaValue[subKey]);
-                                }
-                                else {
-                                    return { allOf: [...schemas] };
-                                }
-                            }
-                            combinedSchema.properties = combinedObject;
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'required':
-                        // If arrays, include all items from both arrays, excluding duplicates
-                        if (isArray(combinedValue) && isArray(schemaValue)) {
-                            combinedSchema.required = uniqueItems(...combinedValue, ...schemaValue);
-                            // If booleans, aet true if either true
-                        }
-                        else if (typeof schemaValue === 'boolean' &&
-                            typeof combinedValue === 'boolean') {
-                            combinedSchema.required = !!combinedValue || !!schemaValue;
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case '$schema':
-                    case '$id':
-                    case 'id':
-                        // Don't combine these keys
-                        break;
-                    case 'title':
-                    case 'description':
-                    case '$comment':
-                        // Return the last value, overwriting any previous one
-                        // These properties are not used for validation, so conflicts don't matter
-                        combinedSchema[key] = schemaValue;
-                        break;
-                    case 'type':
-                        if ((isArray(schemaValue) || isString(schemaValue)) &&
-                            (isArray(combinedValue) || isString(combinedValue))) {
-                            const combinedTypes = commonItems(combinedValue, schemaValue);
-                            if (!combinedTypes.length) {
-                                return { allOf: [...schemas] };
-                            }
-                            combinedSchema.type = combinedTypes.length > 1 ? combinedTypes : combinedTypes[0];
-                        }
-                        else {
-                            return { allOf: [...schemas] };
-                        }
-                        break;
-                    case 'uniqueItems':
-                        // Set true if either true
-                        combinedSchema.uniqueItems = !!combinedValue || !!schemaValue;
-                        break;
-                    default:
-                        return { allOf: [...schemas] };
-                }
-            }
-        }
-    }
-    return combinedSchema;
-}
+import isEqual from 'lodash/isEqual';
+import { isArray, isEmpty, isNumber, isObject, isString } from './validator.functions';
+import { hasOwn, uniqueItems, commonItems } from './utility.functions';
+/**
+ * 'mergeSchemas' function
+ *
+ * Merges multiple JSON schemas into a single schema with combined rules.
+ *
+ * If able to logically merge properties from all schemas,
+ * returns a single schema object containing all merged properties.
+ *
+ * Example: ({ a: b, max: 1 }, { c: d, max: 2 }) => { a: b, c: d, max: 1 }
+ *
+ * If unable to logically merge, returns an allOf schema object containing
+ * an array of the original schemas;
+ *
+ * Example: ({ a: b }, { a: d }) => { allOf: [ { a: b }, { a: d } ] }
+ *
+ * //   schemas - one or more input schemas
+ * //  - merged schema
+ */
+export function mergeSchemas(...schemas) {
+    schemas = schemas.filter(schema => !isEmpty(schema));
+    if (schemas.some(schema => !isObject(schema))) {
+        return null;
+    }
+    const combinedSchema = {};
+    for (const schema of schemas) {
+        for (const key of Object.keys(schema)) {
+            const combinedValue = combinedSchema[key];
+            const schemaValue = schema[key];
+            if (!hasOwn(combinedSchema, key) || isEqual(combinedValue, schemaValue)) {
+                combinedSchema[key] = schemaValue;
+            }
+            else {
+                switch (key) {
+                    case 'allOf':
+                        // Combine all items from both arrays
+                        if (isArray(combinedValue) && isArray(schemaValue)) {
+                            combinedSchema.allOf = mergeSchemas(...combinedValue, ...schemaValue);
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'additionalItems':
+                    case 'additionalProperties':
+                    case 'contains':
+                    case 'propertyNames':
+                        // Merge schema objects
+                        if (isObject(combinedValue) && isObject(schemaValue)) {
+                            combinedSchema[key] = mergeSchemas(combinedValue, schemaValue);
+                            // additionalProperties == false in any schema overrides all other values
+                        }
+                        else if (key === 'additionalProperties' &&
+                            (combinedValue === false || schemaValue === false)) {
+                            combinedSchema.combinedSchema = false;
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'anyOf':
+                    case 'oneOf':
+                    case 'enum':
+                        // Keep only items that appear in both arrays
+                        if (isArray(combinedValue) && isArray(schemaValue)) {
+                            combinedSchema[key] = combinedValue.filter(item1 => schemaValue.findIndex(item2 => isEqual(item1, item2)) > -1);
+                            if (!combinedSchema[key].length) {
+                                return { allOf: [...schemas] };
+                            }
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'definitions':
+                        // Combine keys from both objects
+                        if (isObject(combinedValue) && isObject(schemaValue)) {
+                            const combinedObject = { ...combinedValue };
+                            for (const subKey of Object.keys(schemaValue)) {
+                                if (!hasOwn(combinedObject, subKey) ||
+                                    isEqual(combinedObject[subKey], schemaValue[subKey])) {
+                                    combinedObject[subKey] = schemaValue[subKey];
+                                    // Don't combine matching keys with different values
+                                }
+                                else {
+                                    return { allOf: [...schemas] };
+                                }
+                            }
+                            combinedSchema.definitions = combinedObject;
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'dependencies':
+                        // Combine all keys from both objects
+                        // and merge schemas on matching keys,
+                        // converting from arrays to objects if necessary
+                        if (isObject(combinedValue) && isObject(schemaValue)) {
+                            const combinedObject = { ...combinedValue };
+                            for (const subKey of Object.keys(schemaValue)) {
+                                if (!hasOwn(combinedObject, subKey) ||
+                                    isEqual(combinedObject[subKey], schemaValue[subKey])) {
+                                    combinedObject[subKey] = schemaValue[subKey];
+                                    // If both keys are arrays, include all items from both arrays,
+                                    // excluding duplicates
+                                }
+                                else if (isArray(schemaValue[subKey]) && isArray(combinedObject[subKey])) {
+                                    combinedObject[subKey] =
+                                        uniqueItems(...combinedObject[subKey], ...schemaValue[subKey]);
+                                    // If either key is an object, merge the schemas
+                                }
+                                else if ((isArray(schemaValue[subKey]) || isObject(schemaValue[subKey])) &&
+                                    (isArray(combinedObject[subKey]) || isObject(combinedObject[subKey]))) {
+                                    // If either key is an array, convert it to an object first
+                                    const required = isArray(combinedSchema.required) ?
+                                        combinedSchema.required : [];
+                                    const combinedDependency = isArray(combinedObject[subKey]) ?
+                                        { required: uniqueItems(...required, combinedObject[subKey]) } :
+                                        combinedObject[subKey];
+                                    const schemaDependency = isArray(schemaValue[subKey]) ?
+                                        { required: uniqueItems(...required, schemaValue[subKey]) } :
+                                        schemaValue[subKey];
+                                    combinedObject[subKey] =
+                                        mergeSchemas(combinedDependency, schemaDependency);
+                                }
+                                else {
+                                    return { allOf: [...schemas] };
+                                }
+                            }
+                            combinedSchema.dependencies = combinedObject;
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'items':
+                        // If arrays, keep only items that appear in both arrays
+                        if (isArray(combinedValue) && isArray(schemaValue)) {
+                            combinedSchema.items = combinedValue.filter(item1 => schemaValue.findIndex(item2 => isEqual(item1, item2)) > -1);
+                            if (!combinedSchema.items.length) {
+                                return { allOf: [...schemas] };
+                            }
+                            // If both keys are objects, merge them
+                        }
+                        else if (isObject(combinedValue) && isObject(schemaValue)) {
+                            combinedSchema.items = mergeSchemas(combinedValue, schemaValue);
+                            // If object + array, combine object with each array item
+                        }
+                        else if (isArray(combinedValue) && isObject(schemaValue)) {
+                            combinedSchema.items =
+                                combinedValue.map(item => mergeSchemas(item, schemaValue));
+                        }
+                        else if (isObject(combinedValue) && isArray(schemaValue)) {
+                            combinedSchema.items =
+                                schemaValue.map(item => mergeSchemas(item, combinedValue));
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'multipleOf':
+                        // TODO: Adjust to correctly handle decimal values
+                        // If numbers, set to least common multiple
+                        if (isNumber(combinedValue) && isNumber(schemaValue)) {
+                            const gcd = (x, y) => !y ? x : gcd(y, x % y);
+                            const lcm = (x, y) => (x * y) / gcd(x, y);
+                            combinedSchema.multipleOf = lcm(combinedValue, schemaValue);
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'maximum':
+                    case 'exclusiveMaximum':
+                    case 'maxLength':
+                    case 'maxItems':
+                    case 'maxProperties':
+                        // If numbers, set to lowest value
+                        if (isNumber(combinedValue) && isNumber(schemaValue)) {
+                            combinedSchema[key] = Math.min(combinedValue, schemaValue);
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'minimum':
+                    case 'exclusiveMinimum':
+                    case 'minLength':
+                    case 'minItems':
+                    case 'minProperties':
+                        // If numbers, set to highest value
+                        if (isNumber(combinedValue) && isNumber(schemaValue)) {
+                            combinedSchema[key] = Math.max(combinedValue, schemaValue);
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'not':
+                        // Combine not values into anyOf array
+                        if (isObject(combinedValue) && isObject(schemaValue)) {
+                            const notAnyOf = [combinedValue, schemaValue]
+                                .reduce((notAnyOfArray, notSchema) => isArray(notSchema.anyOf) &&
+                                Object.keys(notSchema).length === 1 ?
+                                [...notAnyOfArray, ...notSchema.anyOf] :
+                                [...notAnyOfArray, notSchema], []);
+                            // TODO: Remove duplicate items from array
+                            combinedSchema.not = { anyOf: notAnyOf };
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'patternProperties':
+                        // Combine all keys from both objects
+                        // and merge schemas on matching keys
+                        if (isObject(combinedValue) && isObject(schemaValue)) {
+                            const combinedObject = { ...combinedValue };
+                            for (const subKey of Object.keys(schemaValue)) {
+                                if (!hasOwn(combinedObject, subKey) ||
+                                    isEqual(combinedObject[subKey], schemaValue[subKey])) {
+                                    combinedObject[subKey] = schemaValue[subKey];
+                                    // If both keys are objects, merge them
+                                }
+                                else if (isObject(schemaValue[subKey]) && isObject(combinedObject[subKey])) {
+                                    combinedObject[subKey] =
+                                        mergeSchemas(combinedObject[subKey], schemaValue[subKey]);
+                                }
+                                else {
+                                    return { allOf: [...schemas] };
+                                }
+                            }
+                            combinedSchema.patternProperties = combinedObject;
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'properties':
+                        // Combine all keys from both objects
+                        // unless additionalProperties === false
+                        // and merge schemas on matching keys
+                        if (isObject(combinedValue) && isObject(schemaValue)) {
+                            const combinedObject = { ...combinedValue };
+                            // If new schema has additionalProperties,
+                            // merge or remove non-matching property keys in combined schema
+                            if (hasOwn(schemaValue, 'additionalProperties')) {
+                                Object.keys(combinedValue)
+                                    .filter(combinedKey => !Object.keys(schemaValue).includes(combinedKey))
+                                    .forEach(nonMatchingKey => {
+                                    if (schemaValue.additionalProperties === false) {
+                                        delete combinedObject[nonMatchingKey];
+                                    }
+                                    else if (isObject(schemaValue.additionalProperties)) {
+                                        combinedObject[nonMatchingKey] = mergeSchemas(combinedObject[nonMatchingKey], schemaValue.additionalProperties);
+                                    }
+                                });
+                            }
+                            for (const subKey of Object.keys(schemaValue)) {
+                                if (isEqual(combinedObject[subKey], schemaValue[subKey]) || (!hasOwn(combinedObject, subKey) &&
+                                    !hasOwn(combinedObject, 'additionalProperties'))) {
+                                    combinedObject[subKey] = schemaValue[subKey];
+                                    // If combined schema has additionalProperties,
+                                    // merge or ignore non-matching property keys in new schema
+                                }
+                                else if (!hasOwn(combinedObject, subKey) &&
+                                    hasOwn(combinedObject, 'additionalProperties')) {
+                                    // If combinedObject.additionalProperties === false,
+                                    // do nothing (don't set key)
+                                    // If additionalProperties is object, merge with new key
+                                    if (isObject(combinedObject.additionalProperties)) {
+                                        combinedObject[subKey] = mergeSchemas(combinedObject.additionalProperties, schemaValue[subKey]);
+                                    }
+                                    // If both keys are objects, merge them
+                                }
+                                else if (isObject(schemaValue[subKey]) &&
+                                    isObject(combinedObject[subKey])) {
+                                    combinedObject[subKey] =
+                                        mergeSchemas(combinedObject[subKey], schemaValue[subKey]);
+                                }
+                                else {
+                                    return { allOf: [...schemas] };
+                                }
+                            }
+                            combinedSchema.properties = combinedObject;
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'required':
+                        // If arrays, include all items from both arrays, excluding duplicates
+                        if (isArray(combinedValue) && isArray(schemaValue)) {
+                            combinedSchema.required = uniqueItems(...combinedValue, ...schemaValue);
+                            // If booleans, aet true if either true
+                        }
+                        else if (typeof schemaValue === 'boolean' &&
+                            typeof combinedValue === 'boolean') {
+                            combinedSchema.required = !!combinedValue || !!schemaValue;
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case '$schema':
+                    case '$id':
+                    case 'id':
+                        // Don't combine these keys
+                        break;
+                    case 'title':
+                    case 'description':
+                    case '$comment':
+                        // Return the last value, overwriting any previous one
+                        // These properties are not used for validation, so conflicts don't matter
+                        combinedSchema[key] = schemaValue;
+                        break;
+                    case 'type':
+                        if ((isArray(schemaValue) || isString(schemaValue)) &&
+                            (isArray(combinedValue) || isString(combinedValue))) {
+                            const combinedTypes = commonItems(combinedValue, schemaValue);
+                            if (!combinedTypes.length) {
+                                return { allOf: [...schemas] };
+                            }
+                            combinedSchema.type = combinedTypes.length > 1 ? combinedTypes : combinedTypes[0];
+                        }
+                        else {
+                            return { allOf: [...schemas] };
+                        }
+                        break;
+                    case 'uniqueItems':
+                        // Set true if either true
+                        combinedSchema.uniqueItems = !!combinedValue || !!schemaValue;
+                        break;
+                    default:
+                        return { allOf: [...schemas] };
+                }
+            }
+        }
+    }
+    return combinedSchema;
+}
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"merge-schemas.function.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-core/src/lib/shared/merge-schemas.function.ts"],"names":[],"mappings":"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","sourcesContent":["import isEqual from 'lodash/isEqual';\r\n\r\nimport {\r\n  isArray, isEmpty, isNumber, isObject, isString\r\n} from './validator.functions';\r\nimport { hasOwn, uniqueItems, commonItems } from './utility.functions';\r\nimport { JsonPointer, Pointer } from './jsonpointer.functions';\r\n\r\n/**\r\n * 'mergeSchemas' function\r\n *\r\n * Merges multiple JSON schemas into a single schema with combined rules.\r\n *\r\n * If able to logically merge properties from all schemas,\r\n * returns a single schema object containing all merged properties.\r\n *\r\n * Example: ({ a: b, max: 1 }, { c: d, max: 2 }) => { a: b, c: d, max: 1 }\r\n *\r\n * If unable to logically merge, returns an allOf schema object containing\r\n * an array of the original schemas;\r\n *\r\n * Example: ({ a: b }, { a: d }) => { allOf: [ { a: b }, { a: d } ] }\r\n *\r\n * //   schemas - one or more input schemas\r\n * //  - merged schema\r\n */\r\nexport function mergeSchemas(...schemas) {\r\n  schemas = schemas.filter(schema => !isEmpty(schema));\r\n  if (schemas.some(schema => !isObject(schema))) { return null; }\r\n  const combinedSchema: any = {};\r\n  for (const schema of schemas) {\r\n    for (const key of Object.keys(schema)) {\r\n      const combinedValue = combinedSchema[key];\r\n      const schemaValue = schema[key];\r\n      if (!hasOwn(combinedSchema, key) || isEqual(combinedValue, schemaValue)) {\r\n        combinedSchema[key] = schemaValue;\r\n      } else {\r\n        switch (key) {\r\n          case 'allOf':\r\n            // Combine all items from both arrays\r\n            if (isArray(combinedValue) && isArray(schemaValue)) {\r\n              combinedSchema.allOf = mergeSchemas(...combinedValue, ...schemaValue);\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'additionalItems': case 'additionalProperties':\r\n          case 'contains': case 'propertyNames':\r\n            // Merge schema objects\r\n            if (isObject(combinedValue) && isObject(schemaValue)) {\r\n              combinedSchema[key] = mergeSchemas(combinedValue, schemaValue);\r\n            // additionalProperties == false in any schema overrides all other values\r\n            } else if (\r\n              key === 'additionalProperties' &&\r\n              (combinedValue === false || schemaValue === false)\r\n            ) {\r\n              combinedSchema.combinedSchema = false;\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'anyOf': case 'oneOf': case 'enum':\r\n            // Keep only items that appear in both arrays\r\n            if (isArray(combinedValue) && isArray(schemaValue)) {\r\n              combinedSchema[key] = combinedValue.filter(item1 =>\r\n                schemaValue.findIndex(item2 => isEqual(item1, item2)) > -1\r\n              );\r\n              if (!combinedSchema[key].length) { return { allOf: [ ...schemas ] }; }\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'definitions':\r\n            // Combine keys from both objects\r\n            if (isObject(combinedValue) && isObject(schemaValue)) {\r\n              const combinedObject = { ...combinedValue };\r\n              for (const subKey of Object.keys(schemaValue)) {\r\n                if (!hasOwn(combinedObject, subKey) ||\r\n                  isEqual(combinedObject[subKey], schemaValue[subKey])\r\n                ) {\r\n                  combinedObject[subKey] = schemaValue[subKey];\r\n                // Don't combine matching keys with different values\r\n                } else {\r\n                  return { allOf: [ ...schemas ] };\r\n                }\r\n              }\r\n              combinedSchema.definitions = combinedObject;\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'dependencies':\r\n            // Combine all keys from both objects\r\n            // and merge schemas on matching keys,\r\n            // converting from arrays to objects if necessary\r\n            if (isObject(combinedValue) && isObject(schemaValue)) {\r\n              const combinedObject = { ...combinedValue };\r\n              for (const subKey of Object.keys(schemaValue)) {\r\n                if (!hasOwn(combinedObject, subKey) ||\r\n                  isEqual(combinedObject[subKey], schemaValue[subKey])\r\n                ) {\r\n                  combinedObject[subKey] = schemaValue[subKey];\r\n                // If both keys are arrays, include all items from both arrays,\r\n                // excluding duplicates\r\n                } else if (\r\n                  isArray(schemaValue[subKey]) && isArray(combinedObject[subKey])\r\n                ) {\r\n                  combinedObject[subKey] =\r\n                    uniqueItems(...combinedObject[subKey], ...schemaValue[subKey]);\r\n                // If either key is an object, merge the schemas\r\n                } else if (\r\n                  (isArray(schemaValue[subKey]) || isObject(schemaValue[subKey])) &&\r\n                  (isArray(combinedObject[subKey]) || isObject(combinedObject[subKey]))\r\n                ) {\r\n                  // If either key is an array, convert it to an object first\r\n                  const required = isArray(combinedSchema.required) ?\r\n                    combinedSchema.required : [];\r\n                  const combinedDependency = isArray(combinedObject[subKey]) ?\r\n                    { required: uniqueItems(...required, combinedObject[subKey]) } :\r\n                    combinedObject[subKey];\r\n                  const schemaDependency = isArray(schemaValue[subKey]) ?\r\n                    { required: uniqueItems(...required, schemaValue[subKey]) } :\r\n                    schemaValue[subKey];\r\n                  combinedObject[subKey] =\r\n                    mergeSchemas(combinedDependency, schemaDependency);\r\n                } else {\r\n                  return { allOf: [ ...schemas ] };\r\n                }\r\n              }\r\n              combinedSchema.dependencies = combinedObject;\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'items':\r\n            // If arrays, keep only items that appear in both arrays\r\n            if (isArray(combinedValue) && isArray(schemaValue)) {\r\n              combinedSchema.items = combinedValue.filter(item1 =>\r\n                schemaValue.findIndex(item2 => isEqual(item1, item2)) > -1\r\n              );\r\n              if (!combinedSchema.items.length) { return { allOf: [ ...schemas ] }; }\r\n            // If both keys are objects, merge them\r\n            } else if (isObject(combinedValue) && isObject(schemaValue)) {\r\n              combinedSchema.items = mergeSchemas(combinedValue, schemaValue);\r\n            // If object + array, combine object with each array item\r\n            } else if (isArray(combinedValue) && isObject(schemaValue)) {\r\n              combinedSchema.items =\r\n                combinedValue.map(item => mergeSchemas(item, schemaValue));\r\n            } else if (isObject(combinedValue) && isArray(schemaValue)) {\r\n              combinedSchema.items =\r\n                schemaValue.map(item => mergeSchemas(item, combinedValue));\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'multipleOf':\r\n            // TODO: Adjust to correctly handle decimal values\r\n            // If numbers, set to least common multiple\r\n            if (isNumber(combinedValue) && isNumber(schemaValue)) {\r\n              const gcd = (x, y) => !y ? x : gcd(y, x % y);\r\n              const lcm = (x, y) => (x * y) / gcd(x, y);\r\n              combinedSchema.multipleOf = lcm(combinedValue, schemaValue);\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'maximum': case 'exclusiveMaximum': case 'maxLength':\r\n          case 'maxItems': case 'maxProperties':\r\n            // If numbers, set to lowest value\r\n            if (isNumber(combinedValue) && isNumber(schemaValue)) {\r\n              combinedSchema[key] = Math.min(combinedValue, schemaValue);\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'minimum': case 'exclusiveMinimum': case 'minLength':\r\n          case 'minItems': case 'minProperties':\r\n            // If numbers, set to highest value\r\n            if (isNumber(combinedValue) && isNumber(schemaValue)) {\r\n              combinedSchema[key] = Math.max(combinedValue, schemaValue);\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'not':\r\n            // Combine not values into anyOf array\r\n            if (isObject(combinedValue) && isObject(schemaValue)) {\r\n              const notAnyOf = [combinedValue, schemaValue]\r\n                .reduce((notAnyOfArray, notSchema) =>\r\n                  isArray(notSchema.anyOf) &&\r\n                  Object.keys(notSchema).length === 1 ?\r\n                    [ ...notAnyOfArray, ...notSchema.anyOf ] :\r\n                    [ ...notAnyOfArray, notSchema ]\r\n                , []);\r\n              // TODO: Remove duplicate items from array\r\n              combinedSchema.not = { anyOf: notAnyOf };\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'patternProperties':\r\n            // Combine all keys from both objects\r\n            // and merge schemas on matching keys\r\n            if (isObject(combinedValue) && isObject(schemaValue)) {\r\n              const combinedObject = { ...combinedValue };\r\n              for (const subKey of Object.keys(schemaValue)) {\r\n                if (!hasOwn(combinedObject, subKey) ||\r\n                  isEqual(combinedObject[subKey], schemaValue[subKey])\r\n                ) {\r\n                  combinedObject[subKey] = schemaValue[subKey];\r\n                // If both keys are objects, merge them\r\n                } else if (\r\n                  isObject(schemaValue[subKey]) && isObject(combinedObject[subKey])\r\n                ) {\r\n                  combinedObject[subKey] =\r\n                    mergeSchemas(combinedObject[subKey], schemaValue[subKey]);\r\n                } else {\r\n                  return { allOf: [ ...schemas ] };\r\n                }\r\n              }\r\n              combinedSchema.patternProperties = combinedObject;\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'properties':\r\n            // Combine all keys from both objects\r\n            // unless additionalProperties === false\r\n            // and merge schemas on matching keys\r\n            if (isObject(combinedValue) && isObject(schemaValue)) {\r\n              const combinedObject = { ...combinedValue };\r\n              // If new schema has additionalProperties,\r\n              // merge or remove non-matching property keys in combined schema\r\n              if (hasOwn(schemaValue, 'additionalProperties')) {\r\n                Object.keys(combinedValue)\r\n                  .filter(combinedKey => !Object.keys(schemaValue).includes(combinedKey))\r\n                  .forEach(nonMatchingKey => {\r\n                    if (schemaValue.additionalProperties === false) {\r\n                      delete combinedObject[nonMatchingKey];\r\n                    } else if (isObject(schemaValue.additionalProperties)) {\r\n                      combinedObject[nonMatchingKey] = mergeSchemas(\r\n                        combinedObject[nonMatchingKey],\r\n                        schemaValue.additionalProperties\r\n                      );\r\n                    }\r\n                  });\r\n              }\r\n              for (const subKey of Object.keys(schemaValue)) {\r\n                if (isEqual(combinedObject[subKey], schemaValue[subKey]) || (\r\n                  !hasOwn(combinedObject, subKey) &&\r\n                  !hasOwn(combinedObject, 'additionalProperties')\r\n                )) {\r\n                  combinedObject[subKey] = schemaValue[subKey];\r\n                // If combined schema has additionalProperties,\r\n                // merge or ignore non-matching property keys in new schema\r\n                } else if (\r\n                  !hasOwn(combinedObject, subKey) &&\r\n                  hasOwn(combinedObject, 'additionalProperties')\r\n                ) {\r\n                  // If combinedObject.additionalProperties === false,\r\n                  // do nothing (don't set key)\r\n                  // If additionalProperties is object, merge with new key\r\n                  if (isObject(combinedObject.additionalProperties)) {\r\n                    combinedObject[subKey] = mergeSchemas(\r\n                      combinedObject.additionalProperties, schemaValue[subKey]\r\n                    );\r\n                  }\r\n                // If both keys are objects, merge them\r\n                } else if (\r\n                  isObject(schemaValue[subKey]) &&\r\n                  isObject(combinedObject[subKey])\r\n                ) {\r\n                  combinedObject[subKey] =\r\n                    mergeSchemas(combinedObject[subKey], schemaValue[subKey]);\r\n                } else {\r\n                  return { allOf: [ ...schemas ] };\r\n                }\r\n              }\r\n              combinedSchema.properties = combinedObject;\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'required':\r\n            // If arrays, include all items from both arrays, excluding duplicates\r\n            if (isArray(combinedValue) && isArray(schemaValue)) {\r\n              combinedSchema.required = uniqueItems(...combinedValue, ...schemaValue);\r\n            // If booleans, aet true if either true\r\n            } else if (\r\n              typeof schemaValue === 'boolean' &&\r\n              typeof combinedValue === 'boolean'\r\n            ) {\r\n              combinedSchema.required = !!combinedValue || !!schemaValue;\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case '$schema': case '$id': case 'id':\r\n            // Don't combine these keys\r\n          break;\r\n          case 'title': case 'description': case '$comment':\r\n            // Return the last value, overwriting any previous one\r\n            // These properties are not used for validation, so conflicts don't matter\r\n            combinedSchema[key] = schemaValue;\r\n          break;\r\n          case 'type':\r\n            if (\r\n              (isArray(schemaValue) || isString(schemaValue)) &&\r\n              (isArray(combinedValue) || isString(combinedValue))\r\n            ) {\r\n              const combinedTypes = commonItems(combinedValue, schemaValue);\r\n              if (!combinedTypes.length) { return { allOf: [ ...schemas ] }; }\r\n              combinedSchema.type = combinedTypes.length > 1 ? combinedTypes : combinedTypes[0];\r\n            } else {\r\n              return { allOf: [ ...schemas ] };\r\n            }\r\n          break;\r\n          case 'uniqueItems':\r\n            // Set true if either true\r\n            combinedSchema.uniqueItems = !!combinedValue || !!schemaValue;\r\n          break;\r\n          default:\r\n            return { allOf: [ ...schemas ] };\r\n        }\r\n      }\r\n    }\r\n  }\r\n  return combinedSchema;\r\n}\r\n"]}