@ngx-formly/core 6.3.12 → 7.0.0-alpha.1

package/esm2022/lib/utils.mjs

@@ -0,0 +1,312 @@
+import { isObservable } from 'rxjs';
+import { AbstractControl } from '@angular/forms';
+import { ChangeDetectorRef, ComponentRef, TemplateRef, Type, VERSION, ɵNoopNgZone } from '@angular/core';
+export function disableTreeValidityCall(form, callback) {
+    const _updateTreeValidity = form._updateTreeValidity.bind(form);
+    form._updateTreeValidity = () => { };
+    callback();
+    form._updateTreeValidity = _updateTreeValidity;
+}
+export function getFieldId(formId, field, index) {
+    if (field.id) {
+        return field.id;
+    }
+    let type = field.type;
+    if (!type && field.template) {
+        type = 'template';
+    }
+    if (type instanceof Type) {
+        type = type.prototype.constructor.name;
+    }
+    return [formId, type, field.key, index].join('_');
+}
+export function hasKey(field) {
+    return !isNil(field.key) && field.key !== '' && (!Array.isArray(field.key) || field.key.length > 0);
+}
+export function getKeyPath(field) {
+    if (!hasKey(field)) {
+        return [];
+    }
+    /* We store the keyPath in the field for performance reasons. This function will be called frequently. */
+    if (field._keyPath?.key !== field.key) {
+        let path = [];
+        if (typeof field.key === 'string') {
+            const key = field.key.indexOf('[') === -1 ? field.key : field.key.replace(/\[(\w+)\]/g, '.$1');
+            path = key.indexOf('.') !== -1 ? key.split('.') : [key];
+        }
+        else if (Array.isArray(field.key)) {
+            path = field.key.slice(0);
+        }
+        else {
+            path = [`${field.key}`];
+        }
+        defineHiddenProp(field, '_keyPath', { key: field.key, path });
+    }
+    return field._keyPath.path.slice(0);
+}
+export const FORMLY_VALIDATORS = ['required', 'pattern', 'minLength', 'maxLength', 'min', 'max'];
+export function assignFieldValue(field, value) {
+    let paths = getKeyPath(field);
+    if (paths.length === 0) {
+        return;
+    }
+    let root = field;
+    while (root.parent) {
+        root = root.parent;
+        paths = [...getKeyPath(root), ...paths];
+    }
+    if (value === undefined && field.resetOnHide) {
+        const k = paths.pop();
+        const m = paths.reduce((model, path) => model[path] || {}, root.model);
+        delete m[k];
+        return;
+    }
+    assignModelValue(root.model, paths, value);
+}
+export function assignModelValue(model, paths, value) {
+    for (let i = 0; i < paths.length - 1; i++) {
+        const path = paths[i];
+        if (!model[path] || !isObject(model[path])) {
+            model[path] = /^\d+$/.test(paths[i + 1]) ? [] : {};
+        }
+        model = model[path];
+    }
+    model[paths[paths.length - 1]] = clone(value);
+}
+export function getFieldValue(field) {
+    let model = field.parent ? field.parent.model : field.model;
+    for (const path of getKeyPath(field)) {
+        if (!model) {
+            return model;
+        }
+        model = model[path];
+    }
+    return model;
+}
+export function reverseDeepMerge(dest, ...args) {
+    args.forEach((src) => {
+        for (const srcArg in src) {
+            if (isNil(dest[srcArg]) || isBlankString(dest[srcArg])) {
+                dest[srcArg] = clone(src[srcArg]);
+            }
+            else if (objAndSameType(dest[srcArg], src[srcArg])) {
+                reverseDeepMerge(dest[srcArg], src[srcArg]);
+            }
+        }
+    });
+    return dest;
+}
+// check a value is null or undefined
+export function isNil(value) {
+    return value == null;
+}
+export function isUndefined(value) {
+    return value === undefined;
+}
+export function isBlankString(value) {
+    return value === '';
+}
+export function isFunction(value) {
+    return typeof value === 'function';
+}
+export function objAndSameType(obj1, obj2) {
+    return (isObject(obj1) &&
+        isObject(obj2) &&
+        Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2) &&
+        !(Array.isArray(obj1) || Array.isArray(obj2)));
+}
+export function isObject(x) {
+    return x != null && typeof x === 'object';
+}
+export function isPromise(obj) {
+    return !!obj && typeof obj.then === 'function';
+}
+export function clone(value) {
+    if (!isObject(value) ||
+        isObservable(value) ||
+        value instanceof TemplateRef ||
+        /* instanceof SafeHtmlImpl */ value.changingThisBreaksApplicationSecurity ||
+        ['RegExp', 'FileList', 'File', 'Blob'].indexOf(value.constructor?.name) !== -1) {
+        return value;
+    }
+    if (value instanceof Set) {
+        return new Set(value);
+    }
+    if (value instanceof Map) {
+        return new Map(value);
+    }
+    if (value instanceof Uint8Array) {
+        return new Uint8Array(value);
+    }
+    if (value instanceof Uint16Array) {
+        return new Uint16Array(value);
+    }
+    if (value instanceof Uint32Array) {
+        return new Uint32Array(value);
+    }
+    // https://github.com/moment/moment/blob/master/moment.js#L252
+    if (value._isAMomentObject && isFunction(value.clone)) {
+        return value.clone();
+    }
+    if (value instanceof AbstractControl) {
+        return null;
+    }
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0).map((v) => clone(v));
+    }
+    // best way to clone a js object maybe
+    // https://stackoverflow.com/questions/41474986/how-to-clone-a-javascript-es6-class-instance
+    const proto = Object.getPrototypeOf(value);
+    let c = Object.create(proto);
+    c = Object.setPrototypeOf(c, proto);
+    // need to make a deep copy so we dont use Object.assign
+    // also Object.assign wont copy property descriptor exactly
+    return Object.keys(value).reduce((newVal, prop) => {
+        const propDesc = Object.getOwnPropertyDescriptor(value, prop);
+        if (propDesc.get) {
+            Object.defineProperty(newVal, prop, propDesc);
+        }
+        else {
+            newVal[prop] = clone(value[prop]);
+        }
+        return newVal;
+    }, c);
+}
+export function defineHiddenProp(field, prop, defaultValue) {
+    Object.defineProperty(field, prop, { enumerable: false, writable: true, configurable: true });
+    field[prop] = defaultValue;
+}
+export function observeDeep(source, paths, setFn) {
+    let observers = [];
+    const unsubscribe = () => {
+        observers.forEach((observer) => observer());
+        observers = [];
+    };
+    const observer = observe(source, paths, ({ firstChange, currentValue }) => {
+        !firstChange && setFn();
+        unsubscribe();
+        if (isObject(currentValue) && currentValue.constructor.name === 'Object') {
+            Object.keys(currentValue).forEach((prop) => {
+                observers.push(observeDeep(source, [...paths, prop], setFn));
+            });
+        }
+    });
+    return () => {
+        observer.unsubscribe();
+        unsubscribe();
+    };
+}
+export function observe(o, paths, setFn) {
+    if (!o._observers) {
+        defineHiddenProp(o, '_observers', {});
+    }
+    let target = o;
+    for (let i = 0; i < paths.length - 1; i++) {
+        if (!target[paths[i]] || !isObject(target[paths[i]])) {
+            target[paths[i]] = /^\d+$/.test(paths[i + 1]) ? [] : {};
+        }
+        target = target[paths[i]];
+    }
+    const key = paths[paths.length - 1];
+    const prop = paths.join('.');
+    if (!o._observers[prop]) {
+        o._observers[prop] = { value: target[key], onChange: [] };
+    }
+    const state = o._observers[prop];
+    if (target[key] !== state.value) {
+        state.value = target[key];
+    }
+    if (setFn && state.onChange.indexOf(setFn) === -1) {
+        state.onChange.push(setFn);
+        setFn({ currentValue: state.value, firstChange: true });
+        if (state.onChange.length >= 1 && isObject(target)) {
+            const { enumerable } = Object.getOwnPropertyDescriptor(target, key) || { enumerable: true };
+            Object.defineProperty(target, key, {
+                enumerable,
+                configurable: true,
+                get: () => state.value,
+                set: (currentValue) => {
+                    if (currentValue !== state.value) {
+                        const previousValue = state.value;
+                        state.value = currentValue;
+                        state.onChange.forEach((changeFn) => changeFn({ previousValue, currentValue, firstChange: false }));
+                    }
+                },
+            });
+        }
+    }
+    return {
+        setValue(currentValue, emitEvent = true) {
+            if (currentValue === state.value) {
+                return;
+            }
+            const previousValue = state.value;
+            state.value = currentValue;
+            state.onChange.forEach((changeFn) => {
+                if (changeFn !== setFn && emitEvent) {
+                    changeFn({ previousValue, currentValue, firstChange: false });
+                }
+            });
+        },
+        unsubscribe() {
+            state.onChange = state.onChange.filter((changeFn) => changeFn !== setFn);
+            if (state.onChange.length === 0) {
+                delete o._observers[prop];
+            }
+        },
+    };
+}
+export function getField(f, key) {
+    key = (Array.isArray(key) ? key.join('.') : key);
+    if (!f.fieldGroup) {
+        return undefined;
+    }
+    for (let i = 0, len = f.fieldGroup.length; i < len; i++) {
+        const c = f.fieldGroup[i];
+        const k = (Array.isArray(c.key) ? c.key.join('.') : c.key);
+        if (k === key) {
+            return c;
+        }
+        if (c.fieldGroup && (isNil(k) || key.indexOf(`${k}.`) === 0)) {
+            const field = getField(c, isNil(k) ? key : key.slice(k.length + 1));
+            if (field) {
+                return field;
+            }
+        }
+    }
+    return undefined;
+}
+export function markFieldForCheck(field) {
+    field._componentRefs?.forEach((ref) => {
+        // NOTE: we cannot use ref.changeDetectorRef, see https://github.com/ngx-formly/ngx-formly/issues/2191
+        if (ref instanceof ComponentRef) {
+            const changeDetectorRef = ref.injector.get(ChangeDetectorRef);
+            changeDetectorRef.markForCheck();
+        }
+        else {
+            ref.markForCheck();
+        }
+    });
+}
+export function isNoopNgZone(ngZone) {
+    return ngZone instanceof ɵNoopNgZone;
+}
+export function isHiddenField(field) {
+    const isHidden = (f) => f.hide || f.expressions?.hide || f.hideExpression;
+    let setDefaultValue = !field.resetOnHide || !isHidden(field);
+    if (!isHidden(field) && field.resetOnHide) {
+        let parent = field.parent;
+        while (parent && !isHidden(parent)) {
+            parent = parent.parent;
+        }
+        setDefaultValue = !parent || !isHidden(parent);
+    }
+    return !setDefaultValue;
+}
+export function isSignalRequired() {
+    return +VERSION.major >= 18 && +VERSION.minor >= 1;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../src/core/src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { FormlyFieldConfig } from './models';\nimport { isObservable } from 'rxjs';\nimport { AbstractControl } from '@angular/forms';\nimport { FormlyFieldConfigCache } from './models';\nimport { ChangeDetectorRef, ComponentRef, NgZone, TemplateRef, Type, VERSION, ɵNoopNgZone } from '@angular/core';\n\nexport function disableTreeValidityCall(form: any, callback: () => void) {\n  const _updateTreeValidity = form._updateTreeValidity.bind(form);\n  form._updateTreeValidity = () => {};\n  callback();\n  form._updateTreeValidity = _updateTreeValidity;\n}\n\nexport function getFieldId(formId: string, field: FormlyFieldConfig, index: string | number) {\n  if (field.id) {\n    return field.id;\n  }\n  let type = field.type;\n  if (!type && field.template) {\n    type = 'template';\n  }\n\n  if (type instanceof Type) {\n    type = type.prototype.constructor.name;\n  }\n\n  return [formId, type, field.key, index].join('_');\n}\n\nexport function hasKey(field: FormlyFieldConfig) {\n  return !isNil(field.key) && field.key !== '' && (!Array.isArray(field.key) || field.key.length > 0);\n}\n\nexport function getKeyPath(field: FormlyFieldConfigCache): string[] {\n  if (!hasKey(field)) {\n    return [];\n  }\n\n  /* We store the keyPath in the field for performance reasons. This function will be called frequently. */\n  if (field._keyPath?.key !== field.key) {\n    let path: (string | number)[] = [];\n    if (typeof field.key === 'string') {\n      const key = field.key.indexOf('[') === -1 ? field.key : field.key.replace(/\\[(\\w+)\\]/g, '.$1');\n      path = key.indexOf('.') !== -1 ? key.split('.') : [key];\n    } else if (Array.isArray(field.key)) {\n      path = field.key.slice(0);\n    } else {\n      path = [`${field.key}`];\n    }\n\n    defineHiddenProp(field, '_keyPath', { key: field.key, path });\n  }\n\n  return field._keyPath.path.slice(0);\n}\n\nexport const FORMLY_VALIDATORS = ['required', 'pattern', 'minLength', 'maxLength', 'min', 'max'];\n\nexport function assignFieldValue(field: FormlyFieldConfigCache, value: any) {\n  let paths = getKeyPath(field);\n  if (paths.length === 0) {\n    return;\n  }\n\n  let root = field;\n  while (root.parent) {\n    root = root.parent;\n    paths = [...getKeyPath(root), ...paths];\n  }\n\n  if (value === undefined && field.resetOnHide) {\n    const k = paths.pop();\n    const m = paths.reduce((model, path) => model[path] || {}, root.model);\n    delete m[k];\n    return;\n  }\n\n  assignModelValue(root.model, paths, value);\n}\n\nexport function assignModelValue(model: any, paths: string[], value: any) {\n  for (let i = 0; i < paths.length - 1; i++) {\n    const path = paths[i];\n    if (!model[path] || !isObject(model[path])) {\n      model[path] = /^\\d+$/.test(paths[i + 1]) ? [] : {};\n    }\n\n    model = model[path];\n  }\n\n  model[paths[paths.length - 1]] = clone(value);\n}\n\nexport function getFieldValue(field: FormlyFieldConfig): any {\n  let model = field.parent ? field.parent.model : field.model;\n  for (const path of getKeyPath(field)) {\n    if (!model) {\n      return model;\n    }\n    model = model[path];\n  }\n\n  return model;\n}\n\nexport function reverseDeepMerge(dest: any, ...args: any[]) {\n  args.forEach((src) => {\n    for (const srcArg in src) {\n      if (isNil(dest[srcArg]) || isBlankString(dest[srcArg])) {\n        dest[srcArg] = clone(src[srcArg]);\n      } else if (objAndSameType(dest[srcArg], src[srcArg])) {\n        reverseDeepMerge(dest[srcArg], src[srcArg]);\n      }\n    }\n  });\n  return dest;\n}\n\n// check a value is null or undefined\nexport function isNil(value: any) {\n  return value == null;\n}\n\nexport function isUndefined(value: any) {\n  return value === undefined;\n}\n\nexport function isBlankString(value: any) {\n  return value === '';\n}\n\nexport function isFunction(value: any) {\n  return typeof value === 'function';\n}\n\nexport function objAndSameType(obj1: any, obj2: any) {\n  return (\n    isObject(obj1) &&\n    isObject(obj2) &&\n    Object.getPrototypeOf(obj1) === Object.getPrototypeOf(obj2) &&\n    !(Array.isArray(obj1) || Array.isArray(obj2))\n  );\n}\n\nexport function isObject(x: any) {\n  return x != null && typeof x === 'object';\n}\n\nexport function isPromise(obj: any): obj is Promise<any> {\n  return !!obj && typeof obj.then === 'function';\n}\n\nexport function clone(value: any): any {\n  if (\n    !isObject(value) ||\n    isObservable(value) ||\n    value instanceof TemplateRef ||\n    /* instanceof SafeHtmlImpl */ value.changingThisBreaksApplicationSecurity ||\n    ['RegExp', 'FileList', 'File', 'Blob'].indexOf(value.constructor?.name) !== -1\n  ) {\n    return value;\n  }\n\n  if (value instanceof Set) {\n    return new Set(value);\n  }\n\n  if (value instanceof Map) {\n    return new Map(value);\n  }\n\n  if (value instanceof Uint8Array) {\n    return new Uint8Array(value);\n  }\n\n  if (value instanceof Uint16Array) {\n    return new Uint16Array(value);\n  }\n\n  if (value instanceof Uint32Array) {\n    return new Uint32Array(value);\n  }\n\n  // https://github.com/moment/moment/blob/master/moment.js#L252\n  if (value._isAMomentObject && isFunction(value.clone)) {\n    return value.clone();\n  }\n\n  if (value instanceof AbstractControl) {\n    return null;\n  }\n\n  if (value instanceof Date) {\n    return new Date(value.getTime());\n  }\n\n  if (Array.isArray(value)) {\n    return value.slice(0).map((v) => clone(v));\n  }\n\n  // best way to clone a js object maybe\n  // https://stackoverflow.com/questions/41474986/how-to-clone-a-javascript-es6-class-instance\n  const proto = Object.getPrototypeOf(value);\n  let c = Object.create(proto);\n  c = Object.setPrototypeOf(c, proto);\n  // need to make a deep copy so we dont use Object.assign\n  // also Object.assign wont copy property descriptor exactly\n  return Object.keys(value).reduce((newVal, prop) => {\n    const propDesc = Object.getOwnPropertyDescriptor(value, prop);\n    if (propDesc.get) {\n      Object.defineProperty(newVal, prop, propDesc);\n    } else {\n      newVal[prop] = clone(value[prop]);\n    }\n\n    return newVal;\n  }, c);\n}\n\nexport function defineHiddenProp(field: any, prop: string, defaultValue: any) {\n  Object.defineProperty(field, prop, { enumerable: false, writable: true, configurable: true });\n  field[prop] = defaultValue;\n}\n\ntype IObserveFn<T> = (change: { currentValue: T; previousValue?: T; firstChange: boolean }) => void;\nexport interface IObserver<T> {\n  setValue: (value: T, emitEvent?: boolean) => void;\n  unsubscribe: () => void;\n}\ninterface IObserveTarget<T> {\n  [prop: string]: any;\n  _observers?: {\n    [prop: string]: {\n      value: T;\n      onChange: IObserveFn<T>[];\n    };\n  };\n}\n\nexport function observeDeep<T = any>(source: IObserveTarget<T>, paths: string[], setFn: () => void): () => void {\n  let observers: (() => void)[] = [];\n\n  const unsubscribe = () => {\n    observers.forEach((observer) => observer());\n    observers = [];\n  };\n  const observer = observe(source, paths, ({ firstChange, currentValue }) => {\n    !firstChange && setFn();\n\n    unsubscribe();\n    if (isObject(currentValue) && currentValue.constructor.name === 'Object') {\n      Object.keys(currentValue).forEach((prop) => {\n        observers.push(observeDeep(source, [...paths, prop], setFn));\n      });\n    }\n  });\n\n  return () => {\n    observer.unsubscribe();\n    unsubscribe();\n  };\n}\n\nexport function observe<T = any>(o: IObserveTarget<T>, paths: string[], setFn?: IObserveFn<T>): IObserver<T> {\n  if (!o._observers) {\n    defineHiddenProp(o, '_observers', {});\n  }\n\n  let target = o;\n  for (let i = 0; i < paths.length - 1; i++) {\n    if (!target[paths[i]] || !isObject(target[paths[i]])) {\n      target[paths[i]] = /^\\d+$/.test(paths[i + 1]) ? [] : {};\n    }\n    target = target[paths[i]];\n  }\n\n  const key = paths[paths.length - 1];\n  const prop = paths.join('.');\n  if (!o._observers[prop]) {\n    o._observers[prop] = { value: target[key], onChange: [] };\n  }\n\n  const state = o._observers[prop];\n  if (target[key] !== state.value) {\n    state.value = target[key];\n  }\n\n  if (setFn && state.onChange.indexOf(setFn) === -1) {\n    state.onChange.push(setFn);\n    setFn({ currentValue: state.value, firstChange: true });\n    if (state.onChange.length >= 1 && isObject(target)) {\n      const { enumerable } = Object.getOwnPropertyDescriptor(target, key) || { enumerable: true };\n      Object.defineProperty(target, key, {\n        enumerable,\n        configurable: true,\n        get: () => state.value,\n        set: (currentValue) => {\n          if (currentValue !== state.value) {\n            const previousValue = state.value;\n            state.value = currentValue;\n            state.onChange.forEach((changeFn) => changeFn({ previousValue, currentValue, firstChange: false }));\n          }\n        },\n      });\n    }\n  }\n\n  return {\n    setValue(currentValue: T, emitEvent = true) {\n      if (currentValue === state.value) {\n        return;\n      }\n\n      const previousValue = state.value;\n      state.value = currentValue;\n      state.onChange.forEach((changeFn) => {\n        if (changeFn !== setFn && emitEvent) {\n          changeFn({ previousValue, currentValue, firstChange: false });\n        }\n      });\n    },\n    unsubscribe() {\n      state.onChange = state.onChange.filter((changeFn) => changeFn !== setFn);\n      if (state.onChange.length === 0) {\n        delete o._observers[prop];\n      }\n    },\n  };\n}\n\nexport function getField(f: FormlyFieldConfig, key: FormlyFieldConfig['key']): FormlyFieldConfig {\n  key = (Array.isArray(key) ? key.join('.') : key) as string;\n  if (!f.fieldGroup) {\n    return undefined;\n  }\n\n  for (let i = 0, len = f.fieldGroup.length; i < len; i++) {\n    const c = f.fieldGroup[i];\n    const k = (Array.isArray(c.key) ? c.key.join('.') : c.key) as string;\n    if (k === key) {\n      return c;\n    }\n\n    if (c.fieldGroup && (isNil(k) || key.indexOf(`${k}.`) === 0)) {\n      const field = getField(c, isNil(k) ? key : key.slice(k.length + 1));\n      if (field) {\n        return field;\n      }\n    }\n  }\n\n  return undefined;\n}\n\nexport function markFieldForCheck(field: FormlyFieldConfigCache) {\n  field._componentRefs?.forEach((ref) => {\n    // NOTE: we cannot use ref.changeDetectorRef, see https://github.com/ngx-formly/ngx-formly/issues/2191\n    if (ref instanceof ComponentRef) {\n      const changeDetectorRef = ref.injector.get(ChangeDetectorRef);\n      changeDetectorRef.markForCheck();\n    } else {\n      ref.markForCheck();\n    }\n  });\n}\n\nexport function isNoopNgZone(ngZone: NgZone) {\n  return ngZone instanceof ɵNoopNgZone;\n}\n\nexport function isHiddenField(field: FormlyFieldConfig) {\n  const isHidden = (f: FormlyFieldConfig) => f.hide || f.expressions?.hide || f.hideExpression;\n  let setDefaultValue = !field.resetOnHide || !isHidden(field);\n  if (!isHidden(field) && field.resetOnHide) {\n    let parent = field.parent;\n    while (parent && !isHidden(parent)) {\n      parent = parent.parent;\n    }\n    setDefaultValue = !parent || !isHidden(parent);\n  }\n\n  return !setDefaultValue;\n}\n\nexport function isSignalRequired() {\n  return +VERSION.major >= 18 && +VERSION.minor >= 1;\n}\n"]}

package/esm2022/preset/preset-substitution.extension.mjs

@@ -0,0 +1,30 @@
+import { ɵreverseDeepMerge } from '@ngx-formly/core';
+export class PresetSubstitutionExtension {
+    constructor(formlyConfig) {
+        this.formlyConfig = formlyConfig;
+    }
+    prePopulate(field) {
+        if (!(typeof field.type === 'string') || field.type[0] !== '#') {
+            return;
+        }
+        const configId = new RegExp(/^#(.+)$/).exec(field.type)?.[1];
+        const preset = this.formlyConfig.presets[configId];
+        const { type: _, ...fieldConfigWithoutType } = field;
+        if (preset) {
+            const merged = ɵreverseDeepMerge(fieldConfigWithoutType, 'getConfiguration' in preset ? preset.getConfiguration() : preset);
+            Object.assign(field, merged);
+        }
+    }
+}
+export function registerLibraryConfigReplacementExtension(formlyConfig) {
+    return {
+        extensions: [
+            {
+                name: 'libraryConfigReplacement',
+                extension: new PresetSubstitutionExtension(formlyConfig),
+                priority: -300,
+            },
+        ],
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/preset/preset.config.mjs

@@ -0,0 +1,11 @@
+import { FormlyConfig, FORMLY_CONFIG } from '@ngx-formly/core';
+import { registerLibraryConfigReplacementExtension } from './preset-substitution.extension';
+export function provideFormlyPreset() {
+    return {
+        provide: FORMLY_CONFIG,
+        useFactory: registerLibraryConfigReplacementExtension,
+        deps: [FormlyConfig],
+        multi: true,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJlc2V0LmNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9jb3JlL3ByZXNldC9zcmMvcHJlc2V0LmNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsWUFBWSxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQy9ELE9BQU8sRUFBRSx5Q0FBeUMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRTVGLE1BQU0sVUFBVSxtQkFBbUI7SUFDakMsT0FBTztRQUNMLE9BQU8sRUFBRSxhQUFhO1FBQ3RCLFVBQVUsRUFBRSx5Q0FBeUM7UUFDckQsSUFBSSxFQUFFLENBQUMsWUFBWSxDQUFDO1FBQ3BCLEtBQUssRUFBRSxJQUFJO0tBQ1osQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQcm92aWRlciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9ybWx5Q29uZmlnLCBGT1JNTFlfQ09ORklHIH0gZnJvbSAnQG5neC1mb3JtbHkvY29yZSc7XG5pbXBvcnQgeyByZWdpc3RlckxpYnJhcnlDb25maWdSZXBsYWNlbWVudEV4dGVuc2lvbiB9IGZyb20gJy4vcHJlc2V0LXN1YnN0aXR1dGlvbi5leHRlbnNpb24nO1xuXG5leHBvcnQgZnVuY3Rpb24gcHJvdmlkZUZvcm1seVByZXNldCgpOiBQcm92aWRlciB7XG4gIHJldHVybiB7XG4gICAgcHJvdmlkZTogRk9STUxZX0NPTkZJRyxcbiAgICB1c2VGYWN0b3J5OiByZWdpc3RlckxpYnJhcnlDb25maWdSZXBsYWNlbWVudEV4dGVuc2lvbixcbiAgICBkZXBzOiBbRm9ybWx5Q29uZmlnXSxcbiAgICBtdWx0aTogdHJ1ZSxcbiAgfTtcbn1cbiJdfQ==

package/esm2022/preset/preset.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { FormlyModule } from '@ngx-formly/core';
+import { provideFormlyPreset } from './preset.config';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-formly/core";
+export class FormlyPresetModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyPresetModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: FormlyPresetModule, imports: [i1.FormlyModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyPresetModule, providers: [provideFormlyPreset()], imports: [FormlyModule.forChild({})] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlyPresetModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [FormlyModule.forChild({})],
+                    providers: [provideFormlyPreset()],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJlc2V0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9jb3JlL3ByZXNldC9zcmMvcHJlc2V0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNoRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQzs7O0FBTXRELE1BQU0sT0FBTyxrQkFBa0I7K0dBQWxCLGtCQUFrQjtnSEFBbEIsa0JBQWtCO2dIQUFsQixrQkFBa0IsYUFGbEIsQ0FBQyxtQkFBbUIsRUFBRSxDQUFDLFlBRHhCLFlBQVksQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDOzs0RkFHeEIsa0JBQWtCO2tCQUo5QixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7b0JBQ3BDLFNBQVMsRUFBRSxDQUFDLG1CQUFtQixFQUFFLENBQUM7aUJBQ25DIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZvcm1seU1vZHVsZSB9IGZyb20gJ0BuZ3gtZm9ybWx5L2NvcmUnO1xuaW1wb3J0IHsgcHJvdmlkZUZvcm1seVByZXNldCB9IGZyb20gJy4vcHJlc2V0LmNvbmZpZyc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtGb3JtbHlNb2R1bGUuZm9yQ2hpbGQoe30pXSxcbiAgcHJvdmlkZXJzOiBbcHJvdmlkZUZvcm1seVByZXNldCgpXSxcbn0pXG5leHBvcnQgY2xhc3MgRm9ybWx5UHJlc2V0TW9kdWxlIHt9XG4iXX0=

package/esm2022/select/select-options.pipe.mjs

@@ -0,0 +1,100 @@
+import { Pipe } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { filter, map, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class FormlySelectOptionsPipe {
+    transform(options, field) {
+        if (!(options instanceof Observable)) {
+            options = this.observableOf(options, field);
+        }
+        else {
+            this.dispose();
+        }
+        return options.pipe(map((value) => this.transformOptions(value, field)));
+    }
+    ngOnDestroy() {
+        this.dispose();
+    }
+    transformOptions(options, field) {
+        const to = this.transformSelectProps(field);
+        const opts = [];
+        const groups = {};
+        options?.forEach((option) => {
+            const o = this.transformOption(option, to);
+            if (o.group) {
+                const id = groups[o.label];
+                if (id === undefined) {
+                    groups[o.label] = opts.push(o) - 1;
+                }
+                else {
+                    o.group.forEach((o) => opts[id].group.push(o));
+                }
+            }
+            else {
+                opts.push(o);
+            }
+        });
+        return opts;
+    }
+    transformOption(option, props) {
+        const group = props.groupProp(option);
+        if (Array.isArray(group)) {
+            return {
+                label: props.labelProp(option),
+                group: group.map((opt) => this.transformOption(opt, props)),
+            };
+        }
+        option = {
+            label: props.labelProp(option),
+            value: props.valueProp(option),
+            disabled: !!props.disabledProp(option),
+        };
+        if (group) {
+            return { label: group, group: [option] };
+        }
+        return option;
+    }
+    transformSelectProps(field) {
+        const props = field?.props || field?.templateOptions || {};
+        const selectPropFn = (prop) => (typeof prop === 'function' ? prop : (o) => o[prop]);
+        return {
+            groupProp: selectPropFn(props.groupProp || 'group'),
+            labelProp: selectPropFn(props.labelProp || 'label'),
+            valueProp: selectPropFn(props.valueProp || 'value'),
+            disabledProp: selectPropFn(props.disabledProp || 'disabled'),
+        };
+    }
+    dispose() {
+        if (this._options) {
+            this._options.complete();
+            this._options = null;
+        }
+        if (this._subscription) {
+            this._subscription.unsubscribe();
+            this._subscription = null;
+        }
+    }
+    observableOf(options, f) {
+        this.dispose();
+        if (f && f.options && f.options.fieldChanges) {
+            this._subscription = f.options.fieldChanges
+                .pipe(filter(({ property, type, field }) => {
+                return (type === 'expressionChanges' &&
+                    (property.indexOf('templateOptions.options') === 0 || property.indexOf('props.options') === 0) &&
+                    field === f &&
+                    Array.isArray(field.props.options) &&
+                    !!this._options);
+            }), tap(() => this._options.next(f.props.options)))
+                .subscribe();
+        }
+        this._options = new BehaviorSubject(options);
+        return this._options.asObservable();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlySelectOptionsPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: FormlySelectOptionsPipe, name: "formlySelectOptions" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlySelectOptionsPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'formlySelectOptions' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select-options.pipe.js","sourceRoot":"","sources":["../../../../../src/core/select/src/select-options.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import { OnDestroy, Pipe, PipeTransform } from '@angular/core';\nimport { BehaviorSubject, Observable, Subscription } from 'rxjs';\nimport { filter, map, tap } from 'rxjs/operators';\nimport { FormlyFieldConfig, FormlyFieldProps } from '@ngx-formly/core';\n\nexport interface FormlySelectOption {\n  label: string;\n  disabled?: boolean;\n  value?: any;\n  group?: FormlySelectOption[];\n}\n\nexport interface FormlyFieldSelectProps extends FormlyFieldProps {\n  groupProp?: string | ((option: any) => string);\n  labelProp?: string | ((option: any) => string);\n  valueProp?: string | ((option: any) => any);\n  disabledProp?: string | ((option: any) => boolean);\n}\n\ntype ITransformOption = {\n  labelProp: (option: any) => string;\n  valueProp: (option: any) => any;\n  disabledProp: (option: any) => boolean;\n  groupProp: (option: any) => string;\n};\n\n@Pipe({ name: 'formlySelectOptions' })\nexport class FormlySelectOptionsPipe implements PipeTransform, OnDestroy {\n  private _subscription: Subscription;\n  private _options: BehaviorSubject<any[]>;\n\n  transform(options: any, field?: FormlyFieldConfig): Observable<FormlySelectOption[]> {\n    if (!(options instanceof Observable)) {\n      options = this.observableOf(options, field);\n    } else {\n      this.dispose();\n    }\n\n    return (options as Observable<any>).pipe(map((value) => this.transformOptions(value, field)));\n  }\n\n  ngOnDestroy(): void {\n    this.dispose();\n  }\n\n  private transformOptions(options: any[], field?: FormlyFieldConfig): FormlySelectOption[] {\n    const to = this.transformSelectProps(field);\n\n    const opts: FormlySelectOption[] = [];\n    const groups: { [id: string]: number } = {};\n\n    options?.forEach((option) => {\n      const o = this.transformOption(option, to);\n      if (o.group) {\n        const id = groups[o.label];\n        if (id === undefined) {\n          groups[o.label] = opts.push(o) - 1;\n        } else {\n          o.group.forEach((o) => opts[id].group.push(o));\n        }\n      } else {\n        opts.push(o);\n      }\n    });\n\n    return opts;\n  }\n\n  private transformOption(option: any, props: ITransformOption): FormlySelectOption {\n    const group = props.groupProp(option);\n    if (Array.isArray(group)) {\n      return {\n        label: props.labelProp(option),\n        group: group.map((opt) => this.transformOption(opt, props)),\n      };\n    }\n\n    option = {\n      label: props.labelProp(option),\n      value: props.valueProp(option),\n      disabled: !!props.disabledProp(option),\n    };\n\n    if (group) {\n      return { label: group, group: [option] };\n    }\n\n    return option;\n  }\n\n  private transformSelectProps(field?: FormlyFieldConfig): ITransformOption {\n    const props = field?.props || field?.templateOptions || {};\n    const selectPropFn = (prop: any) => (typeof prop === 'function' ? prop : (o: any) => o[prop]);\n\n    return {\n      groupProp: selectPropFn(props.groupProp || 'group'),\n      labelProp: selectPropFn(props.labelProp || 'label'),\n      valueProp: selectPropFn(props.valueProp || 'value'),\n      disabledProp: selectPropFn(props.disabledProp || 'disabled'),\n    };\n  }\n\n  private dispose() {\n    if (this._options) {\n      this._options.complete();\n      this._options = null;\n    }\n\n    if (this._subscription) {\n      this._subscription.unsubscribe();\n      this._subscription = null;\n    }\n  }\n\n  private observableOf(options: any, f?: FormlyFieldConfig) {\n    this.dispose();\n    if (f && f.options && f.options.fieldChanges) {\n      this._subscription = f.options.fieldChanges\n        .pipe(\n          filter(({ property, type, field }) => {\n            return (\n              type === 'expressionChanges' &&\n              (property.indexOf('templateOptions.options') === 0 || property.indexOf('props.options') === 0) &&\n              field === f &&\n              Array.isArray(field.props.options) &&\n              !!this._options\n            );\n          }),\n          tap(() => this._options.next(f.props.options as any)),\n        )\n        .subscribe();\n    }\n\n    this._options = new BehaviorSubject(options);\n    return this._options.asObservable();\n  }\n}\n"]}

package/{esm2020 → esm2022}/select/select.module.mjs

@@ -2,15 +2,15 @@ import { NgModule } from '@angular/core';
 import { FormlySelectOptionsPipe } from './select-options.pipe';
 import * as i0 from "@angular/core";
 export class FormlySelectModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlySelectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: FormlySelectModule, declarations: [FormlySelectOptionsPipe], exports: [FormlySelectOptionsPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlySelectModule }); }
 }
-FormlySelectModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlySelectModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-FormlySelectModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlySelectModule, declarations: [FormlySelectOptionsPipe], exports: [FormlySelectOptionsPipe] });
-FormlySelectModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlySelectModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlySelectModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormlySelectModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [FormlySelectOptionsPipe],
                     exports: [FormlySelectOptionsPipe],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9jb3JlL3NlbGVjdC9zcmMvc2VsZWN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDOztBQU1oRSxNQUFNLE9BQU8sa0JBQWtCOztnSEFBbEIsa0JBQWtCO2lIQUFsQixrQkFBa0IsaUJBSGQsdUJBQXVCLGFBQzVCLHVCQUF1QjtpSEFFdEIsa0JBQWtCOzRGQUFsQixrQkFBa0I7a0JBSjlCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsdUJBQXVCLENBQUM7b0JBQ3ZDLE9BQU8sRUFBRSxDQUFDLHVCQUF1QixDQUFDO2lCQUNuQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb3JtbHlTZWxlY3RPcHRpb25zUGlwZSB9IGZyb20gJy4vc2VsZWN0LW9wdGlvbnMucGlwZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW0Zvcm1seVNlbGVjdE9wdGlvbnNQaXBlXSxcbiAgZXhwb3J0czogW0Zvcm1seVNlbGVjdE9wdGlvbnNQaXBlXSxcbn0pXG5leHBvcnQgY2xhc3MgRm9ybWx5U2VsZWN0TW9kdWxlIHt9XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9jb3JlL3NlbGVjdC9zcmMvc2VsZWN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDOztBQU1oRSxNQUFNLE9BQU8sa0JBQWtCOytHQUFsQixrQkFBa0I7Z0hBQWxCLGtCQUFrQixpQkFIZCx1QkFBdUIsYUFDNUIsdUJBQXVCO2dIQUV0QixrQkFBa0I7OzRGQUFsQixrQkFBa0I7a0JBSjlCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsdUJBQXVCLENBQUM7b0JBQ3ZDLE9BQU8sRUFBRSxDQUFDLHVCQUF1QixDQUFDO2lCQUNuQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb3JtbHlTZWxlY3RPcHRpb25zUGlwZSB9IGZyb20gJy4vc2VsZWN0LW9wdGlvbnMucGlwZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW0Zvcm1seVNlbGVjdE9wdGlvbnNQaXBlXSxcbiAgZXhwb3J0czogW0Zvcm1seVNlbGVjdE9wdGlvbnNQaXBlXSxcbn0pXG5leHBvcnQgY2xhc3MgRm9ybWx5U2VsZWN0TW9kdWxlIHt9XG4iXX0=