@ng-formworks/core 17.2.7 → 18.0.0

package/esm2022/lib/shared/form-group.functions.mjs

@@ -0,0 +1,442 @@
+import cloneDeep from 'lodash/cloneDeep';
+import filter from 'lodash/filter';
+import map from 'lodash/map';
+import { UntypedFormArray, UntypedFormControl, UntypedFormGroup } from '@angular/forms';
+import { forEach, hasOwn } from './utility.functions';
+import { getControlValidators, removeRecursiveReferences } from './json-schema.functions';
+import { hasValue, inArray, isArray, isDate, isDefined, isEmpty, isObject, isPrimitive, toJavaScriptType, toSchemaType } from './validator.functions';
+import { JsonPointer } from './jsonpointer.functions';
+import { JsonValidators } from './json.validators';
+/**
+ * FormGroup function library:
+ *
+ * buildFormGroupTemplate:  Builds a FormGroupTemplate from schema
+ *
+ * buildFormGroup:          Builds an Angular FormGroup from a FormGroupTemplate
+ *
+ * mergeValues:
+ *
+ * setRequiredFields:
+ *
+ * formatFormData:
+ *
+ * getControl:
+ *
+ * ---- TODO: ----
+ * TODO: add buildFormGroupTemplateFromLayout function
+ * buildFormGroupTemplateFromLayout: Builds a FormGroupTemplate from a form layout
+ */
+/**
+ * 'buildFormGroupTemplate' function
+ *
+ * Builds a template for an Angular FormGroup from a JSON Schema.
+ *
+ * TODO: add support for pattern properties
+ * https://spacetelescope.github.io/understanding-json-schema/reference/object.html
+ *
+ * //  {any} jsf -
+ * //  {any = null} nodeValue -
+ * //  {boolean = true} mapArrays -
+ * //  {string = ''} schemaPointer -
+ * //  {string = ''} dataPointer -
+ * //  {any = ''} templatePointer -
+ * // {any} -
+ */
+export function buildFormGroupTemplate(jsf, nodeValue = null, setValues = true, schemaPointer = '', dataPointer = '', templatePointer = '') {
+    const schema = JsonPointer.get(jsf.schema, schemaPointer);
+    if (setValues) {
+        if (!isDefined(nodeValue) && (jsf.formOptions.setSchemaDefaults === true ||
+            (jsf.formOptions.setSchemaDefaults === 'auto' && isEmpty(jsf.formValues)))) {
+            nodeValue = JsonPointer.get(jsf.schema, schemaPointer + '/default');
+        }
+    }
+    else {
+        nodeValue = null;
+    }
+    // TODO: If nodeValue still not set, check layout for default value
+    const schemaType = JsonPointer.get(schema, '/type');
+    const controlType = (hasOwn(schema, 'properties') || hasOwn(schema, 'additionalProperties')) &&
+        schemaType === 'object' ? 'FormGroup' :
+        (hasOwn(schema, 'items') || hasOwn(schema, 'additionalItems')) &&
+            schemaType === 'array' ? 'FormArray' :
+            !schemaType && hasOwn(schema, '$ref') ? '$ref' : 'FormControl';
+    const shortDataPointer = removeRecursiveReferences(dataPointer, jsf.dataRecursiveRefMap, jsf.arrayMap);
+    if (!jsf.dataMap.has(shortDataPointer)) {
+        jsf.dataMap.set(shortDataPointer, new Map());
+    }
+    const nodeOptions = jsf.dataMap.get(shortDataPointer);
+    if (!nodeOptions.has('schemaType')) {
+        nodeOptions.set('schemaPointer', schemaPointer);
+        nodeOptions.set('schemaType', schema.type);
+        if (schema.format) {
+            nodeOptions.set('schemaFormat', schema.format);
+            if (!schema.type) {
+                nodeOptions.set('schemaType', 'string');
+            }
+        }
+        if (controlType) {
+            nodeOptions.set('templatePointer', templatePointer);
+            nodeOptions.set('templateType', controlType);
+        }
+    }
+    let controls;
+    const validators = getControlValidators(schema);
+    switch (controlType) {
+        case 'FormGroup':
+            controls = {};
+            if (hasOwn(schema, 'ui:order') || hasOwn(schema, 'properties')) {
+                const propertyKeys = schema['ui:order'] || Object.keys(schema.properties);
+                if (propertyKeys.includes('*') && !hasOwn(schema.properties, '*')) {
+                    const unnamedKeys = Object.keys(schema.properties)
+                        .filter(key => !propertyKeys.includes(key));
+                    for (let i = propertyKeys.length - 1; i >= 0; i--) {
+                        if (propertyKeys[i] === '*') {
+                            propertyKeys.splice(i, 1, ...unnamedKeys);
+                        }
+                    }
+                }
+                propertyKeys
+                    .filter(key => hasOwn(schema.properties, key) ||
+                    hasOwn(schema, 'additionalProperties'))
+                    .forEach(key => controls[key] = buildFormGroupTemplate(jsf, JsonPointer.get(nodeValue, [key]), setValues, schemaPointer + (hasOwn(schema.properties, key) ?
+                    '/properties/' + key : '/additionalProperties'), dataPointer + '/' + key, templatePointer + '/controls/' + key));
+                jsf.formOptions.fieldsRequired = setRequiredFields(schema, controls);
+            }
+            return { controlType, controls, validators };
+        case 'FormArray':
+            controls = [];
+            const minItems = Math.max(schema.minItems || 0, nodeOptions.get('minItems') || 0);
+            const maxItems = Math.min(schema.maxItems || 1000, nodeOptions.get('maxItems') || 1000);
+            let additionalItemsPointer = null;
+            if (isArray(schema.items)) { // 'items' is an array = tuple items
+                const tupleItems = nodeOptions.get('tupleItems') ||
+                    (isArray(schema.items) ? Math.min(schema.items.length, maxItems) : 0);
+                for (let i = 0; i < tupleItems; i++) {
+                    if (i < minItems) {
+                        controls.push(buildFormGroupTemplate(jsf, isArray(nodeValue) ? nodeValue[i] : nodeValue, setValues, schemaPointer + '/items/' + i, dataPointer + '/' + i, templatePointer + '/controls/' + i));
+                    }
+                    else {
+                        const schemaRefPointer = removeRecursiveReferences(schemaPointer + '/items/' + i, jsf.schemaRecursiveRefMap);
+                        const itemRefPointer = removeRecursiveReferences(shortDataPointer + '/' + i, jsf.dataRecursiveRefMap, jsf.arrayMap);
+                        const itemRecursive = itemRefPointer !== shortDataPointer + '/' + i;
+                        if (!hasOwn(jsf.templateRefLibrary, itemRefPointer)) {
+                            jsf.templateRefLibrary[itemRefPointer] = null;
+                            jsf.templateRefLibrary[itemRefPointer] = buildFormGroupTemplate(jsf, null, setValues, schemaRefPointer, itemRefPointer, templatePointer + '/controls/' + i);
+                        }
+                        controls.push(isArray(nodeValue) ?
+                            buildFormGroupTemplate(jsf, nodeValue[i], setValues, schemaPointer + '/items/' + i, dataPointer + '/' + i, templatePointer + '/controls/' + i) :
+                            itemRecursive ?
+                                null : cloneDeep(jsf.templateRefLibrary[itemRefPointer]));
+                    }
+                }
+                // If 'additionalItems' is an object = additional list items (after tuple items)
+                if (schema.items.length < maxItems && isObject(schema.additionalItems)) {
+                    additionalItemsPointer = schemaPointer + '/additionalItems';
+                }
+                // If 'items' is an object = list items only (no tuple items)
+            }
+            else {
+                additionalItemsPointer = schemaPointer + '/items';
+            }
+            if (additionalItemsPointer) {
+                const schemaRefPointer = removeRecursiveReferences(additionalItemsPointer, jsf.schemaRecursiveRefMap);
+                const itemRefPointer = removeRecursiveReferences(shortDataPointer + '/-', jsf.dataRecursiveRefMap, jsf.arrayMap);
+                const itemRecursive = itemRefPointer !== shortDataPointer + '/-';
+                if (!hasOwn(jsf.templateRefLibrary, itemRefPointer)) {
+                    jsf.templateRefLibrary[itemRefPointer] = null;
+                    jsf.templateRefLibrary[itemRefPointer] = buildFormGroupTemplate(jsf, null, setValues, schemaRefPointer, itemRefPointer, templatePointer + '/controls/-');
+                }
+                // const itemOptions = jsf.dataMap.get(itemRefPointer) || new Map();
+                const itemOptions = nodeOptions;
+                if (!itemRecursive || hasOwn(validators, 'required')) {
+                    const arrayLength = Math.min(Math.max(itemRecursive ? 0 :
+                        (itemOptions.get('tupleItems') + itemOptions.get('listItems')) || 0, isArray(nodeValue) ? nodeValue.length : 0), maxItems);
+                    for (let i = controls.length; i < arrayLength; i++) {
+                        controls.push(isArray(nodeValue) ?
+                            buildFormGroupTemplate(jsf, nodeValue[i], setValues, schemaRefPointer, dataPointer + '/-', templatePointer + '/controls/-') :
+                            itemRecursive ?
+                                null : cloneDeep(jsf.templateRefLibrary[itemRefPointer]));
+                    }
+                }
+            }
+            return { controlType, controls, validators };
+        case '$ref':
+            const schemaRef = JsonPointer.compile(schema.$ref);
+            const dataRef = JsonPointer.toDataPointer(schemaRef, schema);
+            const refPointer = removeRecursiveReferences(dataRef, jsf.dataRecursiveRefMap, jsf.arrayMap);
+            if (refPointer && !hasOwn(jsf.templateRefLibrary, refPointer)) {
+                // Set to null first to prevent recursive reference from causing endless loop
+                jsf.templateRefLibrary[refPointer] = null;
+                const newTemplate = buildFormGroupTemplate(jsf, setValues, setValues, schemaRef);
+                if (newTemplate) {
+                    jsf.templateRefLibrary[refPointer] = newTemplate;
+                }
+                else {
+                    delete jsf.templateRefLibrary[refPointer];
+                }
+            }
+            return null;
+        case 'FormControl':
+            const value = {
+                value: setValues && isPrimitive(nodeValue) ? nodeValue : null,
+                disabled: nodeOptions.get('disabled') || false
+            };
+            return { controlType, value, validators };
+        default:
+            return null;
+    }
+}
+/**
+ * 'buildFormGroup' function
+ *
+ * // {any} template -
+ * // {AbstractControl}
+*/
+export function buildFormGroup(template) {
+    const validatorFns = [];
+    let validatorFn = null;
+    if (hasOwn(template, 'validators')) {
+        forEach(template.validators, (parameters, validator) => {
+            if (typeof JsonValidators[validator] === 'function') {
+                validatorFns.push(JsonValidators[validator].apply(null, parameters));
+            }
+        });
+        if (validatorFns.length &&
+            inArray(template.controlType, ['FormGroup', 'FormArray'])) {
+            validatorFn = validatorFns.length > 1 ?
+                JsonValidators.compose(validatorFns) : validatorFns[0];
+        }
+    }
+    if (hasOwn(template, 'controlType')) {
+        switch (template.controlType) {
+            case 'FormGroup':
+                const groupControls = {};
+                forEach(template.controls, (controls, key) => {
+                    const newControl = buildFormGroup(controls);
+                    if (newControl) {
+                        groupControls[key] = newControl;
+                    }
+                });
+                return new UntypedFormGroup(groupControls, validatorFn);
+            case 'FormArray':
+                return new UntypedFormArray(filter(map(template.controls, controls => buildFormGroup(controls))), validatorFn);
+            case 'FormControl':
+                return new UntypedFormControl(template.value, validatorFns);
+        }
+    }
+    return null;
+}
+/**
+ * 'mergeValues' function
+ *
+ * //  {any[]} ...valuesToMerge - Multiple values to merge
+ * // {any} - Merged values
+ */
+export function mergeValues(...valuesToMerge) {
+    let mergedValues = null;
+    for (const currentValue of valuesToMerge) {
+        if (!isEmpty(currentValue)) {
+            if (typeof currentValue === 'object' &&
+                (isEmpty(mergedValues) || typeof mergedValues !== 'object')) {
+                if (isArray(currentValue)) {
+                    mergedValues = [...currentValue];
+                }
+                else if (isObject(currentValue)) {
+                    mergedValues = { ...currentValue };
+                }
+            }
+            else if (typeof currentValue !== 'object') {
+                mergedValues = currentValue;
+            }
+            else if (isObject(mergedValues) && isObject(currentValue)) {
+                Object.assign(mergedValues, currentValue);
+            }
+            else if (isObject(mergedValues) && isArray(currentValue)) {
+                const newValues = [];
+                for (const value of currentValue) {
+                    newValues.push(mergeValues(mergedValues, value));
+                }
+                mergedValues = newValues;
+            }
+            else if (isArray(mergedValues) && isObject(currentValue)) {
+                const newValues = [];
+                for (const value of mergedValues) {
+                    newValues.push(mergeValues(value, currentValue));
+                }
+                mergedValues = newValues;
+            }
+            else if (isArray(mergedValues) && isArray(currentValue)) {
+                const newValues = [];
+                for (let i = 0; i < Math.max(mergedValues.length, currentValue.length); i++) {
+                    if (i < mergedValues.length && i < currentValue.length) {
+                        newValues.push(mergeValues(mergedValues[i], currentValue[i]));
+                    }
+                    else if (i < mergedValues.length) {
+                        newValues.push(mergedValues[i]);
+                    }
+                    else if (i < currentValue.length) {
+                        newValues.push(currentValue[i]);
+                    }
+                }
+                mergedValues = newValues;
+            }
+        }
+    }
+    return mergedValues;
+}
+/**
+ * 'setRequiredFields' function
+ *
+ * // {schema} schema - JSON Schema
+ * // {object} formControlTemplate - Form Control Template object
+ * // {boolean} - true if any fields have been set to required, false if not
+ */
+export function setRequiredFields(schema, formControlTemplate) {
+    let fieldsRequired = false;
+    if (hasOwn(schema, 'required') && !isEmpty(schema.required)) {
+        fieldsRequired = true;
+        let requiredArray = isArray(schema.required) ? schema.required : [schema.required];
+        requiredArray = forEach(requiredArray, key => JsonPointer.set(formControlTemplate, '/' + key + '/validators/required', []));
+    }
+    return fieldsRequired;
+    // TODO: Add support for patternProperties
+    // https://spacetelescope.github.io/understanding-json-schema/reference/object.html#pattern-properties
+}
+/**
+ * 'formatFormData' function
+ *
+ * // {any} formData - Angular FormGroup data object
+ * // {Map<string, any>} dataMap -
+ * // {Map<string, string>} recursiveRefMap -
+ * // {Map<string, number>} arrayMap -
+ * // {boolean = false} fixErrors - if TRUE, tries to fix data
+ * // {any} - formatted data object
+ */
+export function formatFormData(formData, dataMap, recursiveRefMap, arrayMap, returnEmptyFields = false, fixErrors = false) {
+    if (formData === null || typeof formData !== 'object') {
+        return formData;
+    }
+    const formattedData = isArray(formData) ? [] : {};
+    JsonPointer.forEachDeep(formData, (value, dataPointer) => {
+        // If returnEmptyFields === true,
+        // add empty arrays and objects to all allowed keys
+        if (returnEmptyFields && isArray(value)) {
+            JsonPointer.set(formattedData, dataPointer, []);
+        }
+        else if (returnEmptyFields && isObject(value) && !isDate(value)) {
+            JsonPointer.set(formattedData, dataPointer, {});
+        }
+        else {
+            const genericPointer = JsonPointer.has(dataMap, [dataPointer, 'schemaType']) ? dataPointer :
+                removeRecursiveReferences(dataPointer, recursiveRefMap, arrayMap);
+            if (JsonPointer.has(dataMap, [genericPointer, 'schemaType'])) {
+                const schemaType = dataMap.get(genericPointer).get('schemaType');
+                if (schemaType === 'null') {
+                    JsonPointer.set(formattedData, dataPointer, null);
+                }
+                else if ((hasValue(value) || returnEmptyFields) &&
+                    inArray(schemaType, ['string', 'integer', 'number', 'boolean'])) {
+                    const newValue = (fixErrors || (value === null && returnEmptyFields)) ?
+                        toSchemaType(value, schemaType) : toJavaScriptType(value, schemaType);
+                    if (isDefined(newValue) || returnEmptyFields) {
+                        JsonPointer.set(formattedData, dataPointer, newValue);
+                    }
+                }
+                // Finish incomplete 'date-time' entries
+                if (dataMap.get(genericPointer).get('schemaFormat') === 'date-time') {
+                    // "2000-03-14T01:59:26.535" -> "2000-03-14T01:59:26.535Z" (add "Z")
+                    if (/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s][0-2]\d:[0-5]\d:[0-5]\d(?:\.\d+)?$/i.test(value)) {
+                        JsonPointer.set(formattedData, dataPointer, `${value}Z`);
+                        // "2000-03-14T01:59" -> "2000-03-14T01:59:00Z" (add ":00Z")
+                    }
+                    else if (/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s][0-2]\d:[0-5]\d$/i.test(value)) {
+                        JsonPointer.set(formattedData, dataPointer, `${value}:00Z`);
+                        // "2000-03-14" -> "2000-03-14T00:00:00Z" (add "T00:00:00Z")
+                    }
+                    else if (fixErrors && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value)) {
+                        JsonPointer.set(formattedData, dataPointer, `${value}:00:00:00Z`);
+                    }
+                }
+            }
+            else if (typeof value !== 'object' || isDate(value) ||
+                (value === null && returnEmptyFields)) {
+                console.error('formatFormData error: ' +
+                    `Schema type not found for form value at ${genericPointer}`);
+                console.error('dataMap', dataMap);
+                console.error('recursiveRefMap', recursiveRefMap);
+                console.error('genericPointer', genericPointer);
+            }
+        }
+    });
+    return formattedData;
+}
+/**
+ * 'getControl' function
+ *
+ * Uses a JSON Pointer for a data object to retrieve a control from
+ * an Angular formGroup or formGroup template. (Note: though a formGroup
+ * template is much simpler, its basic structure is idential to a formGroup).
+ *
+ * If the optional third parameter 'returnGroup' is set to TRUE, the group
+ * containing the control is returned, rather than the control itself.
+ *
+ * // {FormGroup} formGroup - Angular FormGroup to get value from
+ * // {Pointer} dataPointer - JSON Pointer (string or array)
+ * // {boolean = false} returnGroup - If true, return group containing control
+ * // {group} - Located value (or null, if no control found)
+ */
+export function getControl(formGroup, dataPointer, returnGroup = false) {
+    if (!isObject(formGroup) || !JsonPointer.isJsonPointer(dataPointer)) {
+        if (!JsonPointer.isJsonPointer(dataPointer)) {
+            // If dataPointer input is not a valid JSON pointer, check to
+            // see if it is instead a valid object path, using dot notaion
+            if (typeof dataPointer === 'string') {
+                const formControl = formGroup.get(dataPointer);
+                if (formControl) {
+                    return formControl;
+                }
+            }
+            console.error(`getControl error: Invalid JSON Pointer: ${dataPointer}`);
+        }
+        if (!isObject(formGroup)) {
+            console.error(`getControl error: Invalid formGroup: ${formGroup}`);
+        }
+        return null;
+    }
+    let dataPointerArray = JsonPointer.parse(dataPointer);
+    if (returnGroup) {
+        dataPointerArray = dataPointerArray.slice(0, -1);
+    }
+    // If formGroup input is a real formGroup (not a formGroup template)
+    // try using formGroup.get() to return the control
+    if (typeof formGroup.get === 'function' &&
+        dataPointerArray.every(key => key.indexOf('.') === -1)) {
+        const formControl = formGroup.get(dataPointerArray.join('.'));
+        if (formControl) {
+            return formControl;
+        }
+    }
+    // If formGroup input is a formGroup template,
+    // or formGroup.get() failed to return the control,
+    // search the formGroup object for dataPointer's control
+    let subGroup = formGroup;
+    for (const key of dataPointerArray) {
+        if (hasOwn(subGroup, 'controls')) {
+            subGroup = subGroup.controls;
+        }
+        if (isArray(subGroup) && (key === '-')) {
+            subGroup = subGroup[subGroup.length - 1];
+        }
+        else if (hasOwn(subGroup, key)) {
+            subGroup = subGroup[key];
+        }
+        else {
+            console.error(`getControl error: Unable to find "${key}" item in FormGroup.`);
+            console.error(dataPointer);
+            console.error(formGroup);
+            return;
+        }
+    }
+    return subGroup;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-group.functions.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-core/src/lib/shared/form-group.functions.ts"],"names":[],"mappings":"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","sourcesContent":["import cloneDeep from 'lodash/cloneDeep';\r\nimport filter from 'lodash/filter';\r\nimport map from 'lodash/map';\r\nimport {\r\n  AbstractControl,\r\n  UntypedFormArray,\r\n  UntypedFormControl,\r\n  UntypedFormGroup,\r\n  ValidatorFn\r\n} from '@angular/forms';\r\nimport { forEach, hasOwn } from './utility.functions';\r\nimport { getControlValidators, removeRecursiveReferences } from './json-schema.functions';\r\nimport {\r\n  hasValue,\r\n  inArray,\r\n  isArray,\r\n  isDate,\r\n  isDefined,\r\n  isEmpty,\r\n  isObject,\r\n  isPrimitive,\r\n  SchemaPrimitiveType,\r\n  toJavaScriptType,\r\n  toSchemaType\r\n} from './validator.functions';\r\nimport { JsonPointer, Pointer } from './jsonpointer.functions';\r\nimport { JsonValidators } from './json.validators';\r\n\r\n\r\n\r\n/**\r\n * FormGroup function library:\r\n *\r\n * buildFormGroupTemplate:  Builds a FormGroupTemplate from schema\r\n *\r\n * buildFormGroup:          Builds an Angular FormGroup from a FormGroupTemplate\r\n *\r\n * mergeValues:\r\n *\r\n * setRequiredFields:\r\n *\r\n * formatFormData:\r\n *\r\n * getControl:\r\n *\r\n * ---- TODO: ----\r\n * TODO: add buildFormGroupTemplateFromLayout function\r\n * buildFormGroupTemplateFromLayout: Builds a FormGroupTemplate from a form layout\r\n */\r\n\r\n/**\r\n * 'buildFormGroupTemplate' function\r\n *\r\n * Builds a template for an Angular FormGroup from a JSON Schema.\r\n *\r\n * TODO: add support for pattern properties\r\n * https://spacetelescope.github.io/understanding-json-schema/reference/object.html\r\n *\r\n * //  {any} jsf -\r\n * //  {any = null} nodeValue -\r\n * //  {boolean = true} mapArrays -\r\n * //  {string = ''} schemaPointer -\r\n * //  {string = ''} dataPointer -\r\n * //  {any = ''} templatePointer -\r\n * // {any} -\r\n */\r\nexport function buildFormGroupTemplate(\r\n  jsf: any, nodeValue: any = null, setValues = true,\r\n  schemaPointer = '', dataPointer = '', templatePointer = ''\r\n) {\r\n  const schema = JsonPointer.get(jsf.schema, schemaPointer);\r\n  if (setValues) {\r\n    if (!isDefined(nodeValue) && (\r\n      jsf.formOptions.setSchemaDefaults === true ||\r\n      (jsf.formOptions.setSchemaDefaults === 'auto' && isEmpty(jsf.formValues))\r\n    )) {\r\n      nodeValue = JsonPointer.get(jsf.schema, schemaPointer + '/default');\r\n    }\r\n  } else {\r\n    nodeValue = null;\r\n  }\r\n  // TODO: If nodeValue still not set, check layout for default value\r\n  const schemaType: string | string[] = JsonPointer.get(schema, '/type');\r\n  const controlType =\r\n    (hasOwn(schema, 'properties') || hasOwn(schema, 'additionalProperties')) &&\r\n      schemaType === 'object' ? 'FormGroup' :\r\n      (hasOwn(schema, 'items') || hasOwn(schema, 'additionalItems')) &&\r\n        schemaType === 'array' ? 'FormArray' :\r\n        !schemaType && hasOwn(schema, '$ref') ? '$ref' : 'FormControl';\r\n  const shortDataPointer =\r\n    removeRecursiveReferences(dataPointer, jsf.dataRecursiveRefMap, jsf.arrayMap);\r\n  if (!jsf.dataMap.has(shortDataPointer)) {\r\n    jsf.dataMap.set(shortDataPointer, new Map());\r\n  }\r\n  const nodeOptions = jsf.dataMap.get(shortDataPointer);\r\n  if (!nodeOptions.has('schemaType')) {\r\n    nodeOptions.set('schemaPointer', schemaPointer);\r\n    nodeOptions.set('schemaType', schema.type);\r\n    if (schema.format) {\r\n      nodeOptions.set('schemaFormat', schema.format);\r\n      if (!schema.type) { nodeOptions.set('schemaType', 'string'); }\r\n    }\r\n    if (controlType) {\r\n      nodeOptions.set('templatePointer', templatePointer);\r\n      nodeOptions.set('templateType', controlType);\r\n    }\r\n  }\r\n  let controls: any;\r\n  const validators = getControlValidators(schema);\r\n  switch (controlType) {\r\n\r\n    case 'FormGroup':\r\n      controls = {};\r\n      if (hasOwn(schema, 'ui:order') || hasOwn(schema, 'properties')) {\r\n        const propertyKeys = schema['ui:order'] || Object.keys(schema.properties);\r\n        if (propertyKeys.includes('*') && !hasOwn(schema.properties, '*')) {\r\n          const unnamedKeys = Object.keys(schema.properties)\r\n            .filter(key => !propertyKeys.includes(key));\r\n          for (let i = propertyKeys.length - 1; i >= 0; i--) {\r\n            if (propertyKeys[i] === '*') {\r\n              propertyKeys.splice(i, 1, ...unnamedKeys);\r\n            }\r\n          }\r\n        }\r\n        propertyKeys\r\n          .filter(key => hasOwn(schema.properties, key) ||\r\n            hasOwn(schema, 'additionalProperties')\r\n          )\r\n          .forEach(key => controls[key] = buildFormGroupTemplate(\r\n            jsf, JsonPointer.get(nodeValue, [<string>key]), setValues,\r\n            schemaPointer + (hasOwn(schema.properties, key) ?\r\n              '/properties/' + key : '/additionalProperties'\r\n            ),\r\n            dataPointer + '/' + key,\r\n            templatePointer + '/controls/' + key\r\n          ));\r\n        jsf.formOptions.fieldsRequired = setRequiredFields(schema, controls);\r\n      }\r\n      return { controlType, controls, validators };\r\n\r\n    case 'FormArray':\r\n      controls = [];\r\n      const minItems =\r\n        Math.max(schema.minItems || 0, nodeOptions.get('minItems') || 0);\r\n      const maxItems =\r\n        Math.min(schema.maxItems || 1000, nodeOptions.get('maxItems') || 1000);\r\n      let additionalItemsPointer: string = null;\r\n      if (isArray(schema.items)) { // 'items' is an array = tuple items\r\n        const tupleItems = nodeOptions.get('tupleItems') ||\r\n          (isArray(schema.items) ? Math.min(schema.items.length, maxItems) : 0);\r\n        for (let i = 0; i < tupleItems; i++) {\r\n          if (i < minItems) {\r\n            controls.push(buildFormGroupTemplate(\r\n              jsf, isArray(nodeValue) ? nodeValue[i] : nodeValue, setValues,\r\n              schemaPointer + '/items/' + i,\r\n              dataPointer + '/' + i,\r\n              templatePointer + '/controls/' + i\r\n            ));\r\n          } else {\r\n            const schemaRefPointer = removeRecursiveReferences(\r\n              schemaPointer + '/items/' + i, jsf.schemaRecursiveRefMap\r\n            );\r\n            const itemRefPointer = removeRecursiveReferences(\r\n              shortDataPointer + '/' + i, jsf.dataRecursiveRefMap, jsf.arrayMap\r\n            );\r\n            const itemRecursive = itemRefPointer !== shortDataPointer + '/' + i;\r\n            if (!hasOwn(jsf.templateRefLibrary, itemRefPointer)) {\r\n              jsf.templateRefLibrary[itemRefPointer] = null;\r\n              jsf.templateRefLibrary[itemRefPointer] = buildFormGroupTemplate(\r\n                jsf, null, setValues,\r\n                schemaRefPointer,\r\n                itemRefPointer,\r\n                templatePointer + '/controls/' + i\r\n              );\r\n            }\r\n            controls.push(\r\n              isArray(nodeValue) ?\r\n                buildFormGroupTemplate(\r\n                  jsf, nodeValue[i], setValues,\r\n                  schemaPointer + '/items/' + i,\r\n                  dataPointer + '/' + i,\r\n                  templatePointer + '/controls/' + i\r\n                ) :\r\n                itemRecursive ?\r\n                  null : cloneDeep(jsf.templateRefLibrary[itemRefPointer])\r\n            );\r\n          }\r\n        }\r\n\r\n        // If 'additionalItems' is an object = additional list items (after tuple items)\r\n        if (schema.items.length < maxItems && isObject(schema.additionalItems)) {\r\n          additionalItemsPointer = schemaPointer + '/additionalItems';\r\n        }\r\n\r\n        // If 'items' is an object = list items only (no tuple items)\r\n      } else {\r\n        additionalItemsPointer = schemaPointer + '/items';\r\n      }\r\n\r\n      if (additionalItemsPointer) {\r\n        const schemaRefPointer = removeRecursiveReferences(\r\n          additionalItemsPointer, jsf.schemaRecursiveRefMap\r\n        );\r\n        const itemRefPointer = removeRecursiveReferences(\r\n          shortDataPointer + '/-', jsf.dataRecursiveRefMap, jsf.arrayMap\r\n        );\r\n        const itemRecursive = itemRefPointer !== shortDataPointer + '/-';\r\n        if (!hasOwn(jsf.templateRefLibrary, itemRefPointer)) {\r\n          jsf.templateRefLibrary[itemRefPointer] = null;\r\n          jsf.templateRefLibrary[itemRefPointer] = buildFormGroupTemplate(\r\n            jsf, null, setValues,\r\n            schemaRefPointer,\r\n            itemRefPointer,\r\n            templatePointer + '/controls/-'\r\n          );\r\n        }\r\n        // const itemOptions = jsf.dataMap.get(itemRefPointer) || new Map();\r\n        const itemOptions = nodeOptions;\r\n        if (!itemRecursive || hasOwn(validators, 'required')) {\r\n          const arrayLength = Math.min(Math.max(\r\n            itemRecursive ? 0 :\r\n              (itemOptions.get('tupleItems') + itemOptions.get('listItems')) || 0,\r\n            isArray(nodeValue) ? nodeValue.length : 0\r\n          ), maxItems);\r\n          for (let i = controls.length; i < arrayLength; i++) {\r\n            controls.push(\r\n              isArray(nodeValue) ?\r\n                buildFormGroupTemplate(\r\n                  jsf, nodeValue[i], setValues,\r\n                  schemaRefPointer,\r\n                  dataPointer + '/-',\r\n                  templatePointer + '/controls/-'\r\n                ) :\r\n                itemRecursive ?\r\n                  null : cloneDeep(jsf.templateRefLibrary[itemRefPointer])\r\n            );\r\n          }\r\n        }\r\n      }\r\n      return { controlType, controls, validators };\r\n\r\n    case '$ref':\r\n      const schemaRef = JsonPointer.compile(schema.$ref);\r\n      const dataRef = JsonPointer.toDataPointer(schemaRef, schema);\r\n      const refPointer = removeRecursiveReferences(\r\n        dataRef, jsf.dataRecursiveRefMap, jsf.arrayMap\r\n      );\r\n      if (refPointer && !hasOwn(jsf.templateRefLibrary, refPointer)) {\r\n        // Set to null first to prevent recursive reference from causing endless loop\r\n        jsf.templateRefLibrary[refPointer] = null;\r\n        const newTemplate = buildFormGroupTemplate(jsf, setValues, setValues, schemaRef);\r\n        if (newTemplate) {\r\n          jsf.templateRefLibrary[refPointer] = newTemplate;\r\n        } else {\r\n          delete jsf.templateRefLibrary[refPointer];\r\n        }\r\n      }\r\n      return null;\r\n\r\n    case 'FormControl':\r\n      const value = {\r\n        value: setValues && isPrimitive(nodeValue) ? nodeValue : null,\r\n        disabled: nodeOptions.get('disabled') || false\r\n      };\r\n      return { controlType, value, validators };\r\n\r\n    default:\r\n      return null;\r\n  }\r\n}\r\n\r\n/**\r\n * 'buildFormGroup' function\r\n *\r\n * // {any} template -\r\n * // {AbstractControl}\r\n*/\r\nexport function buildFormGroup(template: any): AbstractControl {\r\n  const validatorFns: ValidatorFn[] = [];\r\n  let validatorFn: ValidatorFn = null;\r\n  if (hasOwn(template, 'validators')) {\r\n    forEach(template.validators, (parameters, validator) => {\r\n      if (typeof JsonValidators[validator] === 'function') {\r\n        validatorFns.push(JsonValidators[validator].apply(null, parameters));\r\n      }\r\n    });\r\n    if (validatorFns.length &&\r\n      inArray(template.controlType, ['FormGroup', 'FormArray'])\r\n    ) {\r\n      validatorFn = validatorFns.length > 1 ?\r\n        JsonValidators.compose(validatorFns) : validatorFns[0];\r\n    }\r\n  }\r\n  if (hasOwn(template, 'controlType')) {\r\n    switch (template.controlType) {\r\n      case 'FormGroup':\r\n        const groupControls: { [key: string]: AbstractControl } = {};\r\n        forEach(template.controls, (controls, key) => {\r\n          const newControl: AbstractControl = buildFormGroup(controls);\r\n          if (newControl) { groupControls[key] = newControl; }\r\n        });\r\n        return new UntypedFormGroup(groupControls, validatorFn);\r\n      case 'FormArray':\r\n        return new UntypedFormArray(filter(map(template.controls,\r\n          controls => buildFormGroup(controls)\r\n        )), validatorFn);\r\n      case 'FormControl':\r\n        return new UntypedFormControl(template.value, validatorFns);\r\n    }\r\n  }\r\n  return null;\r\n}\r\n\r\n/**\r\n * 'mergeValues' function\r\n *\r\n * //  {any[]} ...valuesToMerge - Multiple values to merge\r\n * // {any} - Merged values\r\n */\r\nexport function mergeValues(...valuesToMerge) {\r\n  let mergedValues: any = null;\r\n  for (const currentValue of valuesToMerge) {\r\n    if (!isEmpty(currentValue)) {\r\n      if (typeof currentValue === 'object' &&\r\n        (isEmpty(mergedValues) || typeof mergedValues !== 'object')\r\n      ) {\r\n        if (isArray(currentValue)) {\r\n          mergedValues = [...currentValue];\r\n        } else if (isObject(currentValue)) {\r\n          mergedValues = { ...currentValue };\r\n        }\r\n      } else if (typeof currentValue !== 'object') {\r\n        mergedValues = currentValue;\r\n      } else if (isObject(mergedValues) && isObject(currentValue)) {\r\n        Object.assign(mergedValues, currentValue);\r\n      } else if (isObject(mergedValues) && isArray(currentValue)) {\r\n        const newValues = [];\r\n        for (const value of currentValue) {\r\n          newValues.push(mergeValues(mergedValues, value));\r\n        }\r\n        mergedValues = newValues;\r\n      } else if (isArray(mergedValues) && isObject(currentValue)) {\r\n        const newValues = [];\r\n        for (const value of mergedValues) {\r\n          newValues.push(mergeValues(value, currentValue));\r\n        }\r\n        mergedValues = newValues;\r\n      } else if (isArray(mergedValues) && isArray(currentValue)) {\r\n        const newValues = [];\r\n        for (let i = 0; i < Math.max(mergedValues.length, currentValue.length); i++) {\r\n          if (i < mergedValues.length && i < currentValue.length) {\r\n            newValues.push(mergeValues(mergedValues[i], currentValue[i]));\r\n          } else if (i < mergedValues.length) {\r\n            newValues.push(mergedValues[i]);\r\n          } else if (i < currentValue.length) {\r\n            newValues.push(currentValue[i]);\r\n          }\r\n        }\r\n        mergedValues = newValues;\r\n      }\r\n    }\r\n  }\r\n  return mergedValues;\r\n}\r\n\r\n/**\r\n * 'setRequiredFields' function\r\n *\r\n * // {schema} schema - JSON Schema\r\n * // {object} formControlTemplate - Form Control Template object\r\n * // {boolean} - true if any fields have been set to required, false if not\r\n */\r\nexport function setRequiredFields(schema: any, formControlTemplate: any): boolean {\r\n  let fieldsRequired = false;\r\n  if (hasOwn(schema, 'required') && !isEmpty(schema.required)) {\r\n    fieldsRequired = true;\r\n    let requiredArray = isArray(schema.required) ? schema.required : [schema.required];\r\n    requiredArray = forEach(requiredArray,\r\n      key => JsonPointer.set(formControlTemplate, '/' + key + '/validators/required', [])\r\n    );\r\n  }\r\n  return fieldsRequired;\r\n\r\n  // TODO: Add support for patternProperties\r\n  // https://spacetelescope.github.io/understanding-json-schema/reference/object.html#pattern-properties\r\n}\r\n\r\n/**\r\n * 'formatFormData' function\r\n *\r\n * // {any} formData - Angular FormGroup data object\r\n * // {Map<string, any>} dataMap -\r\n * // {Map<string, string>} recursiveRefMap -\r\n * // {Map<string, number>} arrayMap -\r\n * // {boolean = false} fixErrors - if TRUE, tries to fix data\r\n * // {any} - formatted data object\r\n */\r\nexport function formatFormData(\r\n  formData: any, dataMap: Map<string, any>,\r\n  recursiveRefMap: Map<string, string>, arrayMap: Map<string, number>,\r\n  returnEmptyFields = false, fixErrors = false\r\n): any {\r\n  if (formData === null || typeof formData !== 'object') { return formData; }\r\n  const formattedData = isArray(formData) ? [] : {};\r\n  JsonPointer.forEachDeep(formData, (value, dataPointer) => {\r\n\r\n    // If returnEmptyFields === true,\r\n    // add empty arrays and objects to all allowed keys\r\n    if (returnEmptyFields && isArray(value)) {\r\n      JsonPointer.set(formattedData, dataPointer, []);\r\n    } else if (returnEmptyFields && isObject(value) && !isDate(value)) {\r\n      JsonPointer.set(formattedData, dataPointer, {});\r\n    } else {\r\n      const genericPointer =\r\n        JsonPointer.has(dataMap, [dataPointer, 'schemaType']) ? dataPointer :\r\n          removeRecursiveReferences(dataPointer, recursiveRefMap, arrayMap);\r\n      if (JsonPointer.has(dataMap, [genericPointer, 'schemaType'])) {\r\n        const schemaType: SchemaPrimitiveType | SchemaPrimitiveType[] =\r\n          dataMap.get(genericPointer).get('schemaType');\r\n        if (schemaType === 'null') {\r\n          JsonPointer.set(formattedData, dataPointer, null);\r\n        } else if ((hasValue(value) || returnEmptyFields) &&\r\n          inArray(schemaType, ['string', 'integer', 'number', 'boolean'])\r\n        ) {\r\n          const newValue = (fixErrors || (value === null && returnEmptyFields)) ?\r\n            toSchemaType(value, schemaType) : toJavaScriptType(value, schemaType);\r\n          if (isDefined(newValue) || returnEmptyFields) {\r\n            JsonPointer.set(formattedData, dataPointer, newValue);\r\n          }\r\n        }\r\n\r\n        // Finish incomplete 'date-time' entries\r\n        if (dataMap.get(genericPointer).get('schemaFormat') === 'date-time') {\r\n          // \"2000-03-14T01:59:26.535\" -> \"2000-03-14T01:59:26.535Z\" (add \"Z\")\r\n          if (/^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d[t\\s][0-2]\\d:[0-5]\\d:[0-5]\\d(?:\\.\\d+)?$/i.test(value)) {\r\n            JsonPointer.set(formattedData, dataPointer, `${value}Z`);\r\n            // \"2000-03-14T01:59\" -> \"2000-03-14T01:59:00Z\" (add \":00Z\")\r\n          } else if (/^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d[t\\s][0-2]\\d:[0-5]\\d$/i.test(value)) {\r\n            JsonPointer.set(formattedData, dataPointer, `${value}:00Z`);\r\n            // \"2000-03-14\" -> \"2000-03-14T00:00:00Z\" (add \"T00:00:00Z\")\r\n          } else if (fixErrors && /^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d$/i.test(value)) {\r\n            JsonPointer.set(formattedData, dataPointer, `${value}:00:00:00Z`);\r\n          }\r\n        }\r\n      } else if (typeof value !== 'object' || isDate(value) ||\r\n        (value === null && returnEmptyFields)\r\n      ) {\r\n        console.error('formatFormData error: ' +\r\n          `Schema type not found for form value at ${genericPointer}`);\r\n        console.error('dataMap', dataMap);\r\n        console.error('recursiveRefMap', recursiveRefMap);\r\n        console.error('genericPointer', genericPointer);\r\n      }\r\n    }\r\n  });\r\n  return formattedData;\r\n}\r\n\r\n/**\r\n * 'getControl' function\r\n *\r\n * Uses a JSON Pointer for a data object to retrieve a control from\r\n * an Angular formGroup or formGroup template. (Note: though a formGroup\r\n * template is much simpler, its basic structure is idential to a formGroup).\r\n *\r\n * If the optional third parameter 'returnGroup' is set to TRUE, the group\r\n * containing the control is returned, rather than the control itself.\r\n *\r\n * // {FormGroup} formGroup - Angular FormGroup to get value from\r\n * // {Pointer} dataPointer - JSON Pointer (string or array)\r\n * // {boolean = false} returnGroup - If true, return group containing control\r\n * // {group} - Located value (or null, if no control found)\r\n */\r\nexport function getControl(\r\n  formGroup: any, dataPointer: Pointer, returnGroup = false\r\n): any {\r\n  if (!isObject(formGroup) || !JsonPointer.isJsonPointer(dataPointer)) {\r\n    if (!JsonPointer.isJsonPointer(dataPointer)) {\r\n      // If dataPointer input is not a valid JSON pointer, check to\r\n      // see if it is instead a valid object path, using dot notaion\r\n      if (typeof dataPointer === 'string') {\r\n        const formControl = formGroup.get(dataPointer);\r\n        if (formControl) { return formControl; }\r\n      }\r\n      console.error(`getControl error: Invalid JSON Pointer: ${dataPointer}`);\r\n    }\r\n    if (!isObject(formGroup)) {\r\n      console.error(`getControl error: Invalid formGroup: ${formGroup}`);\r\n    }\r\n    return null;\r\n  }\r\n  let dataPointerArray = JsonPointer.parse(dataPointer);\r\n  if (returnGroup) { dataPointerArray = dataPointerArray.slice(0, -1); }\r\n\r\n  // If formGroup input is a real formGroup (not a formGroup template)\r\n  // try using formGroup.get() to return the control\r\n  if (typeof formGroup.get === 'function' &&\r\n    dataPointerArray.every(key => key.indexOf('.') === -1)\r\n  ) {\r\n    const formControl = formGroup.get(dataPointerArray.join('.'));\r\n    if (formControl) { return formControl; }\r\n  }\r\n\r\n  // If formGroup input is a formGroup template,\r\n  // or formGroup.get() failed to return the control,\r\n  // search the formGroup object for dataPointer's control\r\n  let subGroup = formGroup;\r\n  for (const key of dataPointerArray) {\r\n    if (hasOwn(subGroup, 'controls')) { subGroup = subGroup.controls; }\r\n    if (isArray(subGroup) && (key === '-')) {\r\n      subGroup = subGroup[subGroup.length - 1];\r\n    } else if (hasOwn(subGroup, key)) {\r\n      subGroup = subGroup[key];\r\n    } else {\r\n      console.error(`getControl error: Unable to find \"${key}\" item in FormGroup.`);\r\n      console.error(dataPointer);\r\n      console.error(formGroup);\r\n      return;\r\n    }\r\n  }\r\n  return subGroup;\r\n}\r\n"]}

package/esm2022/lib/shared/format-regex.constants.mjs

@@ -0,0 +1,54 @@
+// updated from AJV fast format regular expressions:
+// https://github.com/epoberezkin/ajv/blob/master/lib/compile/formats.js
+export const jsonSchemaFormatTests = {
+    'date': /^\d\d\d\d-[0-1]\d-[0-3]\d$/,
+    'time': /^[0-2]\d:[0-5]\d:[0-5]\d(?:\.\d+)?(?:z|[+-]\d\d:\d\d)?$/i,
+    // Modified to allow incomplete entries, such as
+    // "2000-03-14T01:59:26.535" (needs "Z") or "2000-03-14T01:59" (needs ":00Z")
+    'date-time': /^\d\d\d\d-[0-1]\d-[0-3]\d[t\s][0-2]\d:[0-5]\d(?::[0-5]\d)?(?:\.\d+)?(?:z|[+-]\d\d:\d\d)?$/i,
+    // email (sources from jsen validator):
+    // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363
+    // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'willful violation')
+    'email': /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i,
+    'hostname': /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*$/i,
+    // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html
+    'ipv4': /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/,
+    // optimized http://stackoverflow.com/questions/53497/regular-expression-that-matches-valid-ipv6-addresses
+    // tslint:disable-next-line:max-line-length
+    'ipv6': /^\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(?:%.+)?\s*$/i,
+    // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js
+    'uri': /^(?:[a-z][a-z0-9+-.]*)(?::|\/)\/?[^\s]*$/i,
+    // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A
+    'uri-reference': /^(?:(?:[a-z][a-z0-9+-.]*:)?\/\/)?[^\s]*$/i,
+    // uri-template: https://tools.ietf.org/html/rfc6570
+    // tslint:disable-next-line:max-line-length
+    'uri-template': /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
+    // For the source: https://gist.github.com/dperini/729294
+    // For test cases: https://mathiasbynens.be/demo/url-regex
+    // tslint:disable-next-line:max-line-length
+    // @todo Delete current URL in favour of the commented out URL rule when this ajv issue is fixed https://github.com/eslint/eslint/issues/7983.
+    // tslint:disable-next-line:max-line-length
+    // URL: /^(?:(?:https?|ftp):\/\/)(?:\S+(?::\S*)?@)?(?:(?!10(?:\.\d{1,3}){3})(?!127(?:\.\d{1,3}){3})(?!169\.254(?:\.\d{1,3}){2})(?!192\.168(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)(?:\.(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
+    // tslint:disable-next-line:max-line-length
+    'url': /^(?:(?:http[s\u017F]?|ftp):\/\/)(?:(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+(?::(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?@)?(?:(?!10(?:\.[0-9]{1,3}){3})(?!127(?:\.[0-9]{1,3}){3})(?!169\.254(?:\.[0-9]{1,3}){2})(?!192\.168(?:\.[0-9]{1,3}){2})(?!172\.(?:1[6-9]|2[0-9]|3[01])(?:\.[0-9]{1,3}){2})(?:[1-9][0-9]?|1[0-9][0-9]|2[01][0-9]|22[0-3])(?:\.(?:1?[0-9]{1,2}|2[0-4][0-9]|25[0-5])){2}(?:\.(?:[1-9][0-9]?|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))|(?:(?:(?:[0-9KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-?)*(?:[0-9KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)(?:\.(?:(?:[0-9KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-?)*(?:[0-9KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)*(?:\.(?:(?:[KSa-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]){2,})))(?::[0-9]{2,5})?(?:\/(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?$/i,
+    // uuid: http://tools.ietf.org/html/rfc4122
+    'uuid': /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
+    // optimized https://gist.github.com/olmokramer/82ccce673f86db7cda5e
+    // tslint:disable-next-line:max-line-length
+    'color': /^\s*(#(?:[\da-f]{3}){1,2}|rgb\((?:\d{1,3},\s*){2}\d{1,3}\)|rgba\((?:\d{1,3},\s*){3}\d*\.?\d+\)|hsl\(\d{1,3}(?:,\s*\d{1,3}%){2}\)|hsla\(\d{1,3}(?:,\s*\d{1,3}%){2},\s*\d*\.?\d+\))\s*$/gi,
+    // JSON-pointer: https://tools.ietf.org/html/rfc6901
+    'json-pointer': /^(?:\/(?:[^~/]|~0|~1)*)*$|^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
+    'relative-json-pointer': /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
+    'regex': function (str) {
+        if (/[^\\]\\Z/.test(str)) {
+            return false;
+        }
+        try {
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format-regex.constants.js","sourceRoot":"","sources":["../../../../../../projects/ng-formworks-core/src/lib/shared/format-regex.constants.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,wEAAwE;AAExE,MAAM,CAAC,MAAM,qBAAqB,GAAG;IAEnC,MAAM,EAAE,4BAA4B;IAEpC,MAAM,EAAE,0DAA0D;IAElE,gDAAgD;IAChD,6EAA6E;IAC7E,WAAW,EAAE,4FAA4F;IAEzG,uCAAuC;IACvC,mHAAmH;IACnH,8FAA8F;IAC9F,OAAO,EAAE,kHAAkH;IAE3H,UAAU,EAAE,oFAAoF;IAEhG,mHAAmH;IACnH,MAAM,EAAE,2EAA2E;IAEnF,0GAA0G;IAC1G,2CAA2C;IAC3C,MAAM,EAAE,opCAAopC;IAE5pC,4EAA4E;IAC5E,KAAK,EAAE,2CAA2C;IAElD,+DAA+D;IAC/D,eAAe,EAAE,2CAA2C;IAE5D,oDAAoD;IACpD,2CAA2C;IAC3C,cAAc,EAAE,mLAAmL;IAEnM,yDAAyD;IACzD,0DAA0D;IAC1D,2CAA2C;IAC3C,8IAA8I;IAC9I,2CAA2C;IAC3C,igBAAigB;IACjgB,2CAA2C;IAC3C,KAAK,EAAE,2rDAA2rD;IAElsD,2CAA2C;IAC3C,MAAM,EAAE,8DAA8D;IAEtE,oEAAoE;IACpE,2CAA2C;IAC3C,OAAO,EAAE,yLAAyL;IAElM,oDAAoD;IACpD,cAAc,EAAE,wFAAwF;IAExG,uBAAuB,EAAE,kDAAkD;IAE3E,OAAO,EAAE,UAAU,GAAG;QACpB,IAAI,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YAAC,OAAO,KAAK,CAAC;QAAC,CAAC;QAC3C,IAAI,CAAC;YACH,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;CAEF,CAAC","sourcesContent":["// updated from AJV fast format regular expressions:\r\n// https://github.com/epoberezkin/ajv/blob/master/lib/compile/formats.js\r\n\r\nexport const jsonSchemaFormatTests = {\r\n\r\n  'date': /^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d$/,\r\n\r\n  'time': /^[0-2]\\d:[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:z|[+-]\\d\\d:\\d\\d)?$/i,\r\n\r\n  // Modified to allow incomplete entries, such as\r\n  // \"2000-03-14T01:59:26.535\" (needs \"Z\") or \"2000-03-14T01:59\" (needs \":00Z\")\r\n  'date-time': /^\\d\\d\\d\\d-[0-1]\\d-[0-3]\\d[t\\s][0-2]\\d:[0-5]\\d(?::[0-5]\\d)?(?:\\.\\d+)?(?:z|[+-]\\d\\d:\\d\\d)?$/i,\r\n\r\n  // email (sources from jsen validator):\r\n  // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363\r\n  // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'willful violation')\r\n  'email': /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i,\r\n\r\n  'hostname': /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*$/i,\r\n\r\n  // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html\r\n  'ipv4': /^(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)$/,\r\n\r\n  // optimized http://stackoverflow.com/questions/53497/regular-expression-that-matches-valid-ipv6-addresses\r\n  // tslint:disable-next-line:max-line-length\r\n  'ipv6': /^\\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(?:%.+)?\\s*$/i,\r\n\r\n  // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js\r\n  'uri': /^(?:[a-z][a-z0-9+-.]*)(?::|\\/)\\/?[^\\s]*$/i,\r\n\r\n  // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A\r\n  'uri-reference': /^(?:(?:[a-z][a-z0-9+-.]*:)?\\/\\/)?[^\\s]*$/i,\r\n\r\n  // uri-template: https://tools.ietf.org/html/rfc6570\r\n  // tslint:disable-next-line:max-line-length\r\n  'uri-template': /^(?:(?:[^\\x00-\\x20\"'<>%\\\\^`{|}]|%[0-9a-f]{2})|\\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\\*)?)*\\})*$/i,\r\n\r\n  // For the source: https://gist.github.com/dperini/729294\r\n  // For test cases: https://mathiasbynens.be/demo/url-regex\r\n  // tslint:disable-next-line:max-line-length\r\n  // @todo Delete current URL in favour of the commented out URL rule when this ajv issue is fixed https://github.com/eslint/eslint/issues/7983.\r\n  // tslint:disable-next-line:max-line-length\r\n  // URL: /^(?:(?:https?|ftp):\\/\\/)(?:\\S+(?::\\S*)?@)?(?:(?!10(?:\\.\\d{1,3}){3})(?!127(?:\\.\\d{1,3}){3})(?!169\\.254(?:\\.\\d{1,3}){2})(?!192\\.168(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u{00a1}-\\u{ffff}0-9]+-?)*[a-z\\u{00a1}-\\u{ffff}0-9]+)(?:\\.(?:[a-z\\u{00a1}-\\u{ffff}0-9]+-?)*[a-z\\u{00a1}-\\u{ffff}0-9]+)*(?:\\.(?:[a-z\\u{00a1}-\\u{ffff}]{2,})))(?::\\d{2,5})?(?:\\/[^\\s]*)?$/iu,\r\n  // tslint:disable-next-line:max-line-length\r\n  'url': /^(?:(?:http[s\\u017F]?|ftp):\\/\\/)(?:(?:[\\0-\\x08\\x0E-\\x1F!-\\x9F\\xA1-\\u167F\\u1681-\\u1FFF\\u200B-\\u2027\\u202A-\\u202E\\u2030-\\u205E\\u2060-\\u2FFF\\u3001-\\uD7FF\\uE000-\\uFEFE\\uFF00-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+(?::(?:[\\0-\\x08\\x0E-\\x1F!-\\x9F\\xA1-\\u167F\\u1681-\\u1FFF\\u200B-\\u2027\\u202A-\\u202E\\u2030-\\u205E\\u2060-\\u2FFF\\u3001-\\uD7FF\\uE000-\\uFEFE\\uFF00-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*)?@)?(?:(?!10(?:\\.[0-9]{1,3}){3})(?!127(?:\\.[0-9]{1,3}){3})(?!169\\.254(?:\\.[0-9]{1,3}){2})(?!192\\.168(?:\\.[0-9]{1,3}){2})(?!172\\.(?:1[6-9]|2[0-9]|3[01])(?:\\.[0-9]{1,3}){2})(?:[1-9][0-9]?|1[0-9][0-9]|2[01][0-9]|22[0-3])(?:\\.(?:1?[0-9]{1,2}|2[0-4][0-9]|25[0-5])){2}(?:\\.(?:[1-9][0-9]?|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))|(?:(?:(?:[0-9KSa-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+-?)*(?:[0-9KSa-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+)(?:\\.(?:(?:[0-9KSa-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+-?)*(?:[0-9KSa-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])+)*(?:\\.(?:(?:[KSa-z\\xA1-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]){2,})))(?::[0-9]{2,5})?(?:\\/(?:[\\0-\\x08\\x0E-\\x1F!-\\x9F\\xA1-\\u167F\\u1681-\\u1FFF\\u200B-\\u2027\\u202A-\\u202E\\u2030-\\u205E\\u2060-\\u2FFF\\u3001-\\uD7FF\\uE000-\\uFEFE\\uFF00-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*)?$/i,\r\n\r\n  // uuid: http://tools.ietf.org/html/rfc4122\r\n  'uuid': /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,\r\n\r\n  // optimized https://gist.github.com/olmokramer/82ccce673f86db7cda5e\r\n  // tslint:disable-next-line:max-line-length\r\n  'color': /^\\s*(#(?:[\\da-f]{3}){1,2}|rgb\\((?:\\d{1,3},\\s*){2}\\d{1,3}\\)|rgba\\((?:\\d{1,3},\\s*){3}\\d*\\.?\\d+\\)|hsl\\(\\d{1,3}(?:,\\s*\\d{1,3}%){2}\\)|hsla\\(\\d{1,3}(?:,\\s*\\d{1,3}%){2},\\s*\\d*\\.?\\d+\\))\\s*$/gi,\r\n\r\n  // JSON-pointer: https://tools.ietf.org/html/rfc6901\r\n  'json-pointer': /^(?:\\/(?:[^~/]|~0|~1)*)*$|^#(?:\\/(?:[a-z0-9_\\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,\r\n\r\n  'relative-json-pointer': /^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^~/]|~0|~1)*)*)$/,\r\n\r\n  'regex': function (str) {\r\n    if (/[^\\\\]\\\\Z/.test(str)) { return false; }\r\n    try {\r\n      return true;\r\n    } catch (e) {\r\n      return false;\r\n    }\r\n  }\r\n\r\n};\r\n\r\nexport type JsonSchemaFormatNames =\r\n  'date' | 'time' | 'date-time' | 'email' | 'hostname' | 'ipv4' | 'ipv6' |\r\n  'uri' | 'uri-reference' | 'uri-template' | 'url' | 'uuid' | 'color' |\r\n  'json-pointer' | 'relative-json-pointer' | 'regex';\r\n"]}