@quadrel-enterprise-ui/framework 1.0.0 → 18.19.1

package/esm2022/lib/forms/reactive-forms/controls/form-array.mjs

@@ -0,0 +1,320 @@
+import { QdFormControl } from './form-control';
+import { AbstractControl, UntypedFormArray } from '@angular/forms';
+export class QdFormArray extends UntypedFormArray {
+    _itemControlOptions;
+    _onChange = [];
+    constructor(valuesOrControls, itemValidatorOrOpts, itemAsyncValidator, validator, asyncValidator) {
+        const itemValidators = pickItemValidators(itemValidatorOrOpts);
+        const itemAsyncValidators = pickItemAsyncValidators(itemAsyncValidator, itemValidatorOrOpts);
+        const validators = pickValidators(validator, itemValidatorOrOpts);
+        const asyncValidators = pickAsyncValidators(asyncValidator, itemValidatorOrOpts);
+        const itemControlOptions = {
+            validators: itemValidators,
+            asyncValidators: itemAsyncValidators
+        };
+        if (isOptionsObj(itemValidatorOrOpts)) {
+            if (itemValidatorOrOpts.itemUpdateOn) {
+                itemControlOptions.updateOn = itemValidatorOrOpts.itemUpdateOn;
+            }
+            if (itemValidatorOrOpts.itemInitialValueIsDefault) {
+                itemControlOptions.initialValueIsDefault = itemValidatorOrOpts.itemInitialValueIsDefault;
+            }
+        }
+        super(valuesOrControls.map(valueOrControl => valueOrControl instanceof AbstractControl
+            ? valueOrControl
+            : new QdFormControl(valueOrControl, itemControlOptions)), validators, asyncValidators);
+        this._itemControlOptions = itemControlOptions;
+        this.valueChanges.subscribe(value => {
+            this._onChange.forEach(changeFn => changeFn(value));
+        });
+    }
+    /**
+     * Register a listener for value changes.
+     *
+     * @param fn The method that is called when the value changes.
+     */
+    registerOnChange(fn) {
+        this._onChange.push(fn);
+    }
+    /**
+     * Function to unregister a value change event listener.
+     */
+    _unregisterOnChange(fn) {
+        removeListItem(this._onChange, fn);
+    }
+    /**
+     * Register a listener for disabled events.
+     *
+     * @param fn The method that is called when the disabled status changes.
+     */
+    registerOnDisabledChange(fn) {
+        // TODO check whether there is a cleaner way to set the disabled change handler in future angular updates
+        // @ts-ignore
+        this._onDisabledChange.push(fn);
+    }
+    /**
+     * Function to unregister a disabled event listener.
+     */
+    _unregisterOnDisabledChange(fn) {
+        // @ts-ignore
+        removeListItem(this._onDisabledChange, fn);
+    }
+    /**
+     * Insert a new `AbstractControl` at the end of the array.
+     *
+     * @param valueOrControl Value for automatically generated form control or given form control to be inserted
+     * @param options Specifies whether this FormArray instance should emit events after a new
+     *     control is added.
+     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
+     * `valueChanges` observables emit events with the latest status and value when the control is
+     * inserted. When false, no events are emitted.
+     */
+    push(valueOrControl, options) {
+        super.push(valueOrControl instanceof AbstractControl
+            ? valueOrControl
+            : new QdFormControl(valueOrControl, this._itemControlOptions), options);
+    }
+    /**
+     * Insert a new `AbstractControl` at the given `index` in the array.
+     *
+     * @param index Index in the array to insert the control
+     * @param valueOrControl Value for automatically generated form control or given form control to be inserted
+     * @param options Specifies whether this FormArray instance should emit events after a new
+     *     control is inserted.
+     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
+     * `valueChanges` observables emit events with the latest status and value when the control is
+     * inserted. When false, no events are emitted.
+     */
+    insert(index, valueOrControl, options) {
+        super.insert(index, valueOrControl instanceof AbstractControl
+            ? valueOrControl
+            : new QdFormControl(valueOrControl, this._itemControlOptions), options);
+    }
+    /**
+     * Replace an existing control.
+     *
+     * @param index Index in the array to replace the control
+     * @param valueOrControl The value for automatically generated form control or
+     *     given form control to replace the existing control
+     * @param options Specifies whether this FormArray instance should emit events after an
+     *     existing control is replaced with a new one.
+     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
+     * `valueChanges` observables emit events with the latest status and value when the control is
+     * replaced with a new one. When false, no events are emitted.
+     */
+    setControl(index, valueOrControl, options) {
+        super.setControl(index, valueOrControl instanceof AbstractControl
+            ? valueOrControl
+            : new QdFormControl(valueOrControl, this._itemControlOptions), options);
+    }
+    reset(value, options) {
+        while (this.length !== 0) {
+            this.removeAt(0);
+        }
+        super.reset(value, options);
+    }
+    /**
+     * Sets the synchronous item validators that are active on this control.  Calling
+     * this overwrites any existing synchronous validators for every item.
+     *
+     * When you add or remove an item validator at run time, you must call
+     * `updateItemValuesAndValidity()` for the new validation to take effect.
+     *
+     * If you want to add a new item validator without affecting existing ones, consider
+     * using `addItemValidators()` method instead.
+     */
+    setItemValidators(validators) {
+        this.controls.forEach(control => control.setValidators(validators));
+    }
+    /**
+     * Sets the asynchronous item validators that are active on this control. Calling this
+     * overwrites any existing asynchronous validators for every item.
+     *
+     * When you add or remove an item validator at run time, you must call
+     * `updateItemValuesAndValidity()` for the new validation to take effect.
+     *
+     * If you want to add a new item validator without affecting existing ones, consider
+     * using `addItemAsyncValidators()` method instead.
+     */
+    setItemAsyncValidators(validators) {
+        this.controls.forEach(control => control.setAsyncValidators(validators));
+    }
+    /**
+     * Add a synchronous item validator or validators to all item controls, without affecting other validators.
+     *
+     * When you add or remove an item validator at run time, you must call
+     * `updateItemValuesAndValidity()` for the new validation to take effect.
+     *
+     * Adding a validator that already exists will have no effect. If duplicate validator functions
+     * are present in the `validators` array, only the first instance would be added to a form
+     * control.
+     *
+     * @param validators The new item validator function or functions to add to all item controls.
+     */
+    addItemValidators(validators) {
+        this.controls.forEach(control => control.addValidators(validators));
+    }
+    /**
+     * Add an asynchronous item validator or validators to all item controls, without affecting other
+     * validators.
+     *
+     * When you add or remove an item validator at run time, you must call
+     * `updateItemValuesAndValidity()` for the new validation to take effect.
+     *
+     * Adding a validator that already exists will have no effect.
+     *
+     * @param validators The new asynchronous item validator function or functions to add to all item controls.
+     */
+    addItemAsyncValidators(validators) {
+        this.controls.forEach(control => control.addAsyncValidators(validators));
+    }
+    /**
+     * Remove a synchronous item validator from all item controls, without affecting other validators.
+     * Validators are compared by function reference; you must pass a reference to the exact same
+     * validator function as the one that was originally set. If a provided validator is not found,
+     * it is ignored.
+     *
+     * When you add or remove an item validator at run time, you must call
+     * `updateItemValuesAndValidity()` for the new validation to take effect.
+     *
+     * @param validators The item validator or validators to remove.
+     */
+    removeItemValidators(validators) {
+        this.controls.forEach(control => control.removeValidators(validators));
+    }
+    /**
+     * Remove an asynchronous item validator from all item controls, without affecting other validators.
+     * Validators are compared by function reference; you must pass a reference to the exact same
+     * validator function as the one that was originally set. If a provided validator is not found, it
+     * is ignored.
+     *
+     * When you add or remove an item validator at run time, you must call
+     * `updateItemValuesAndValidity()` for the new validation to take effect.
+     *
+     * @param validators The asynchronous item validator or validators to remove.
+     */
+    removeItemAsyncValidators(validators) {
+        this.controls.forEach(control => control.removeAsyncValidators(validators));
+    }
+    /**
+     * Check whether a synchronous item validator function is present on all item controls. The provided
+     * validator must be a reference to the exact same function that was provided.
+     *
+     * @param validator The item validator to check for presence. Compared by function reference.
+     * @returns Whether the provided validator was found on all item controls.
+     */
+    hasItemValidator(validator) {
+        return this.controls.every(control => control.hasValidator(validator));
+    }
+    /**
+     * Check whether an asynchronous item validator function is present on all item controls. The provided
+     * validator must be a reference to the exact same function that was provided.
+     *
+     * @param validator The asynchronous item validator to check for presence. Compared by function
+     *     reference.
+     * @returns Whether the provided asynchronous validator was found on all item controls.
+     */
+    hasItemAsyncValidator(validator) {
+        return this.controls.every(control => control.hasAsyncValidator(validator));
+    }
+    /**
+     * Empties out the synchronous validator list for every item.
+     *
+     * When you add or remove an item validator at run time, you must call
+     * `updateItemValuesAndValidity()` for the new validation to take effect.
+     *
+     */
+    clearItemValidators() {
+        this.controls.forEach(control => control.clearValidators());
+    }
+    /**
+     * Empties out the async validator list for every item.
+     *
+     * When you add or remove a validator at run time, you must call
+     * `updateItemValuesAndValidity()` for the new validation to take effect.
+     *
+     */
+    clearItemAsyncValidators() {
+        this.controls.forEach(control => control.clearAsyncValidators());
+    }
+    /**
+     * Recalculates the value and validation status for all item controls.
+     *
+     * By default, it also updates the value and validity of its ancestors.
+     *
+     * @param opts Configuration options determine how the control propagates changes and emits events
+     * after updates and validity checks are applied.
+     * * `onlySelf`: When true, only update each single item control. When false or not supplied,
+     * update all direct ancestors. Default is false.
+     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
+     * `valueChanges`
+     * observables emit events with the latest status and value when the item control is updated.
+     * When false, no events are emitted.
+     */
+    updateItemValuesAndValidity(opts = {}) {
+        this.controls.forEach(control => control.updateValueAndValidity(opts));
+    }
+}
+/**
+ * Gets item validators from either an options object or given validators.
+ */
+export function pickItemValidators(itemValidatorOrOpts) {
+    return (isOptionsObj(itemValidatorOrOpts) ? itemValidatorOrOpts.itemValidators : itemValidatorOrOpts) || null;
+}
+/**
+ * Gets item async validators from either an options object or given validators.
+ */
+export function pickItemAsyncValidators(itemAsyncValidator, itemValidatorOrOpts) {
+    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+        if (isOptionsObj(itemValidatorOrOpts) && itemAsyncValidator) {
+            console.warn(validatorsDroppedWithOptsWarning);
+        }
+    }
+    return (isOptionsObj(itemValidatorOrOpts) ? itemValidatorOrOpts.itemAsyncValidators : itemAsyncValidator) || null;
+}
+/**
+ * Gets validators from either an options object or given validators.
+ */
+function pickValidators(validator, itemValidatorOrOpts) {
+    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+        if (isOptionsObj(itemValidatorOrOpts) && validator) {
+            console.warn(validatorsDroppedWithOptsWarning);
+        }
+    }
+    return (isOptionsObj(itemValidatorOrOpts) ? itemValidatorOrOpts.validators : validator) || null;
+}
+/**
+ * Gets async validators from either an options object or given validators.
+ */
+function pickAsyncValidators(asyncValidator, itemValidatorOrOpts) {
+    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+        if (isOptionsObj(itemValidatorOrOpts) && asyncValidator) {
+            console.warn(validatorsDroppedWithOptsWarning);
+        }
+    }
+    return (isOptionsObj(itemValidatorOrOpts) ? itemValidatorOrOpts.asyncValidators : asyncValidator) || null;
+}
+function isOptionsObj(itemValidatorOrOpts) {
+    return itemValidatorOrOpts != null && !Array.isArray(itemValidatorOrOpts) && typeof itemValidatorOrOpts === 'object';
+}
+function removeListItem(list, el) {
+    const index = list.indexOf(el);
+    if (index > -1)
+        list.splice(index, 1);
+}
+const validatorsDroppedWithOptsWarning = `
+  It looks like you're constructing using a QdFormControl with both an options argument and an
+  validators argument. Mixing these arguments will cause your validators in the argument to be dropped.
+  You should either put all your validators in the options object, or in separate validators
+  arguments. For example:
+
+  // Using validators arguments
+  fc = new QdFormControl(42, Validators.required, myAsyncValidator);
+
+  // Using AbstractControlOptions
+  fc = new QdFormControl(42, {validators: Validators.required, asyncValidators: myAV});
+
+  // Do NOT mix them: validators in additional argument will be dropped!
+  fc = new QdFormControl(42, {validators: Validators.required}, /* Oops! */ myAsyncValidator);
+`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-array.js","sourceRoot":"","sources":["../../../../../../../libs/qd-ui/src/lib/forms/reactive-forms/controls/form-array.ts"],"names":[],"mappings":"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","sourcesContent":["import { QdFormControl } from './form-control';\nimport {\n  AbstractControl,\n  AbstractControlOptions,\n  AsyncValidatorFn,\n  FormControlOptions,\n  UntypedFormArray,\n  ValidatorFn,\n  ɵTypedOrUntyped\n} from '@angular/forms';\n\ndeclare global {\n  const ngDevMode: boolean;\n}\n\nexport type QdFormArrayValuesOrControls<T> = T[] | AbstractControl[];\nexport type QdFormArrayItemValidator = ValidatorFn | ValidatorFn[] | null;\nexport type QdFormArrayItemValidatorOrOpts = QdFormArrayItemValidator | QdFormArrayOptions;\nexport type QdFormArrayItemAsyncValidator = AsyncValidatorFn | AsyncValidatorFn[] | null;\nexport type QdFormArrayValidator = QdFormArrayItemValidator;\nexport type QdFormArrayAsyncValidator = QdFormArrayItemAsyncValidator;\n\nexport class QdFormArray<T> extends UntypedFormArray implements AbstractControl {\n  private _itemControlOptions: FormControlOptions;\n  private _onChange: Array<(value: T) => void> = [];\n\n  constructor(\n    valuesOrControls: QdFormArrayValuesOrControls<T>,\n    itemValidatorOrOpts?: QdFormArrayItemValidatorOrOpts,\n    itemAsyncValidator?: QdFormArrayItemAsyncValidator,\n    validator?: QdFormArrayValidator,\n    asyncValidator?: QdFormArrayAsyncValidator\n  ) {\n    const itemValidators = pickItemValidators(itemValidatorOrOpts);\n    const itemAsyncValidators = pickItemAsyncValidators(itemAsyncValidator, itemValidatorOrOpts);\n    const validators = pickValidators(validator, itemValidatorOrOpts);\n    const asyncValidators = pickAsyncValidators(asyncValidator, itemValidatorOrOpts);\n\n    const itemControlOptions: FormControlOptions = {\n      validators: itemValidators,\n      asyncValidators: itemAsyncValidators\n    };\n\n    if (isOptionsObj(itemValidatorOrOpts)) {\n      if (itemValidatorOrOpts.itemUpdateOn) {\n        itemControlOptions.updateOn = itemValidatorOrOpts.itemUpdateOn;\n      }\n\n      if (itemValidatorOrOpts.itemInitialValueIsDefault) {\n        itemControlOptions.initialValueIsDefault = itemValidatorOrOpts.itemInitialValueIsDefault;\n      }\n    }\n\n    super(\n      valuesOrControls.map(valueOrControl =>\n        valueOrControl instanceof AbstractControl\n          ? valueOrControl\n          : new QdFormControl(valueOrControl, itemControlOptions)\n      ),\n      validators,\n      asyncValidators\n    );\n    this._itemControlOptions = itemControlOptions;\n\n    this.valueChanges.subscribe(value => {\n      this._onChange.forEach(changeFn => changeFn(value));\n    });\n  }\n\n  /**\n   * Register a listener for value changes.\n   *\n   * @param fn The method that is called when the value changes.\n   */\n  registerOnChange(fn: (value: T) => void): void {\n    this._onChange.push(fn);\n  }\n\n  /**\n   * Function to unregister a value change event listener.\n   */\n  _unregisterOnChange(fn: (value: T) => void): void {\n    removeListItem(this._onChange, fn);\n  }\n\n  /**\n   * Register a listener for disabled events.\n   *\n   * @param fn The method that is called when the disabled status changes.\n   */\n  registerOnDisabledChange(fn: (isDisabled: boolean) => void): void {\n    // TODO check whether there is a cleaner way to set the disabled change handler in future angular updates\n    // @ts-ignore\n    this._onDisabledChange.push(fn);\n  }\n\n  /**\n   * Function to unregister a disabled event listener.\n   */\n  _unregisterOnDisabledChange(fn: (isDisabled: boolean) => void): void {\n    // @ts-ignore\n    removeListItem(this._onDisabledChange, fn);\n  }\n\n  /**\n   * Insert a new `AbstractControl` at the end of the array.\n   *\n   * @param valueOrControl Value for automatically generated form control or given form control to be inserted\n   * @param options Specifies whether this FormArray instance should emit events after a new\n   *     control is added.\n   * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n   * `valueChanges` observables emit events with the latest status and value when the control is\n   * inserted. When false, no events are emitted.\n   */\n  override push(\n    valueOrControl: T | AbstractControl,\n    options?: {\n      emitEvent?: boolean;\n    }\n  ): void {\n    super.push(\n      valueOrControl instanceof AbstractControl\n        ? valueOrControl\n        : new QdFormControl(valueOrControl, this._itemControlOptions),\n      options\n    );\n  }\n\n  /**\n   * Insert a new `AbstractControl` at the given `index` in the array.\n   *\n   * @param index Index in the array to insert the control\n   * @param valueOrControl Value for automatically generated form control or given form control to be inserted\n   * @param options Specifies whether this FormArray instance should emit events after a new\n   *     control is inserted.\n   * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n   * `valueChanges` observables emit events with the latest status and value when the control is\n   * inserted. When false, no events are emitted.\n   */\n  override insert(\n    index: number,\n    valueOrControl: T | AbstractControl,\n    options?: {\n      emitEvent?: boolean;\n    }\n  ): void {\n    super.insert(\n      index,\n      valueOrControl instanceof AbstractControl\n        ? valueOrControl\n        : new QdFormControl(valueOrControl, this._itemControlOptions),\n      options\n    );\n  }\n\n  /**\n   * Replace an existing control.\n   *\n   * @param index Index in the array to replace the control\n   * @param valueOrControl The value for automatically generated form control or\n   *     given form control to replace the existing control\n   * @param options Specifies whether this FormArray instance should emit events after an\n   *     existing control is replaced with a new one.\n   * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n   * `valueChanges` observables emit events with the latest status and value when the control is\n   * replaced with a new one. When false, no events are emitted.\n   */\n  override setControl(\n    index: number,\n    valueOrControl: T | AbstractControl,\n    options?: {\n      emitEvent?: boolean;\n    }\n  ): void {\n    super.setControl(\n      index,\n      valueOrControl instanceof AbstractControl\n        ? valueOrControl\n        : new QdFormControl(valueOrControl, this._itemControlOptions),\n      options\n    );\n  }\n\n  override reset(\n    value?: ɵTypedOrUntyped<T, any, any>,\n    options?: {\n      onlySelf?: boolean;\n      emitEvent?: boolean;\n    }\n  ): void {\n    while (this.length !== 0) {\n      this.removeAt(0);\n    }\n    super.reset(value, options);\n  }\n\n  /**\n   * Sets the synchronous item validators that are active on this control.  Calling\n   * this overwrites any existing synchronous validators for every item.\n   *\n   * When you add or remove an item validator at run time, you must call\n   * `updateItemValuesAndValidity()` for the new validation to take effect.\n   *\n   * If you want to add a new item validator without affecting existing ones, consider\n   * using `addItemValidators()` method instead.\n   */\n  setItemValidators(validators: ValidatorFn | ValidatorFn[] | null): void {\n    this.controls.forEach(control => control.setValidators(validators));\n  }\n\n  /**\n   * Sets the asynchronous item validators that are active on this control. Calling this\n   * overwrites any existing asynchronous validators for every item.\n   *\n   * When you add or remove an item validator at run time, you must call\n   * `updateItemValuesAndValidity()` for the new validation to take effect.\n   *\n   * If you want to add a new item validator without affecting existing ones, consider\n   * using `addItemAsyncValidators()` method instead.\n   */\n  setItemAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[] | null): void {\n    this.controls.forEach(control => control.setAsyncValidators(validators));\n  }\n\n  /**\n   * Add a synchronous item validator or validators to all item controls, without affecting other validators.\n   *\n   * When you add or remove an item validator at run time, you must call\n   * `updateItemValuesAndValidity()` for the new validation to take effect.\n   *\n   * Adding a validator that already exists will have no effect. If duplicate validator functions\n   * are present in the `validators` array, only the first instance would be added to a form\n   * control.\n   *\n   * @param validators The new item validator function or functions to add to all item controls.\n   */\n  addItemValidators(validators: ValidatorFn | ValidatorFn[]): void {\n    this.controls.forEach(control => control.addValidators(validators));\n  }\n\n  /**\n   * Add an asynchronous item validator or validators to all item controls, without affecting other\n   * validators.\n   *\n   * When you add or remove an item validator at run time, you must call\n   * `updateItemValuesAndValidity()` for the new validation to take effect.\n   *\n   * Adding a validator that already exists will have no effect.\n   *\n   * @param validators The new asynchronous item validator function or functions to add to all item controls.\n   */\n  addItemAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[]): void {\n    this.controls.forEach(control => control.addAsyncValidators(validators));\n  }\n\n  /**\n   * Remove a synchronous item validator from all item controls, without affecting other validators.\n   * Validators are compared by function reference; you must pass a reference to the exact same\n   * validator function as the one that was originally set. If a provided validator is not found,\n   * it is ignored.\n   *\n   * When you add or remove an item validator at run time, you must call\n   * `updateItemValuesAndValidity()` for the new validation to take effect.\n   *\n   * @param validators The item validator or validators to remove.\n   */\n  removeItemValidators(validators: ValidatorFn | ValidatorFn[]): void {\n    this.controls.forEach(control => control.removeValidators(validators));\n  }\n\n  /**\n   * Remove an asynchronous item validator from all item controls, without affecting other validators.\n   * Validators are compared by function reference; you must pass a reference to the exact same\n   * validator function as the one that was originally set. If a provided validator is not found, it\n   * is ignored.\n   *\n   * When you add or remove an item validator at run time, you must call\n   * `updateItemValuesAndValidity()` for the new validation to take effect.\n   *\n   * @param validators The asynchronous item validator or validators to remove.\n   */\n  removeItemAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[]): void {\n    this.controls.forEach(control => control.removeAsyncValidators(validators));\n  }\n\n  /**\n   * Check whether a synchronous item validator function is present on all item controls. The provided\n   * validator must be a reference to the exact same function that was provided.\n   *\n   * @param validator The item validator to check for presence. Compared by function reference.\n   * @returns Whether the provided validator was found on all item controls.\n   */\n  hasItemValidator(validator: ValidatorFn): boolean {\n    return this.controls.every(control => control.hasValidator(validator));\n  }\n\n  /**\n   * Check whether an asynchronous item validator function is present on all item controls. The provided\n   * validator must be a reference to the exact same function that was provided.\n   *\n   * @param validator The asynchronous item validator to check for presence. Compared by function\n   *     reference.\n   * @returns Whether the provided asynchronous validator was found on all item controls.\n   */\n  hasItemAsyncValidator(validator: AsyncValidatorFn): boolean {\n    return this.controls.every(control => control.hasAsyncValidator(validator));\n  }\n\n  /**\n   * Empties out the synchronous validator list for every item.\n   *\n   * When you add or remove an item validator at run time, you must call\n   * `updateItemValuesAndValidity()` for the new validation to take effect.\n   *\n   */\n  clearItemValidators(): void {\n    this.controls.forEach(control => control.clearValidators());\n  }\n\n  /**\n   * Empties out the async validator list for every item.\n   *\n   * When you add or remove a validator at run time, you must call\n   * `updateItemValuesAndValidity()` for the new validation to take effect.\n   *\n   */\n  clearItemAsyncValidators(): void {\n    this.controls.forEach(control => control.clearAsyncValidators());\n  }\n\n  /**\n   * Recalculates the value and validation status for all item controls.\n   *\n   * By default, it also updates the value and validity of its ancestors.\n   *\n   * @param opts Configuration options determine how the control propagates changes and emits events\n   * after updates and validity checks are applied.\n   * * `onlySelf`: When true, only update each single item control. When false or not supplied,\n   * update all direct ancestors. Default is false.\n   * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n   * `valueChanges`\n   * observables emit events with the latest status and value when the item control is updated.\n   * When false, no events are emitted.\n   */\n  updateItemValuesAndValidity(opts: { onlySelf?: boolean; emitEvent?: boolean } = {}): void {\n    this.controls.forEach(control => control.updateValueAndValidity(opts));\n  }\n}\n\nexport interface QdFormArrayOptions extends AbstractControlOptions {\n  /**\n   * @description\n   * The list of validators applied to the controls of the items.\n   */\n  itemValidators?: QdFormArrayValidator;\n\n  /**\n   * @description\n   * The list of async validators applied to the controls of the items.\n   */\n  itemAsyncValidators?: QdFormArrayAsyncValidator;\n\n  /**\n   * @description\n   * The event name for the controls of the items to update upon.\n   */\n  itemUpdateOn?: 'change' | 'blur' | 'submit';\n\n  /**\n   * @description\n   * Whether to use the initial value used to construct the QdFormControl as its default value as\n   * well. If this option is false or not provided, the default value of a QdFormControl is `null`.\n   * When a QdFormControl is {@link QdFormControl#reset} without an explicit value, its value reverts to\n   * its default value.\n   */\n  itemInitialValueIsDefault?: boolean;\n}\n\n/**\n * Gets item validators from either an options object or given validators.\n */\nexport function pickItemValidators(itemValidatorOrOpts?: QdFormArrayItemValidatorOrOpts): QdFormArrayValidator {\n  return (isOptionsObj(itemValidatorOrOpts) ? itemValidatorOrOpts.itemValidators : itemValidatorOrOpts) || null;\n}\n\n/**\n * Gets item async validators from either an options object or given validators.\n */\nexport function pickItemAsyncValidators(\n  itemAsyncValidator?: QdFormArrayAsyncValidator,\n  itemValidatorOrOpts?: QdFormArrayItemValidatorOrOpts\n): QdFormArrayAsyncValidator {\n  if (typeof ngDevMode === 'undefined' || ngDevMode) {\n    if (isOptionsObj(itemValidatorOrOpts) && itemAsyncValidator) {\n      console.warn(validatorsDroppedWithOptsWarning);\n    }\n  }\n  return (isOptionsObj(itemValidatorOrOpts) ? itemValidatorOrOpts.itemAsyncValidators : itemAsyncValidator) || null;\n}\n\n/**\n * Gets validators from either an options object or given validators.\n */\nfunction pickValidators(\n  validator?: QdFormArrayValidator,\n  itemValidatorOrOpts?: QdFormArrayItemValidatorOrOpts\n): QdFormArrayValidator {\n  if (typeof ngDevMode === 'undefined' || ngDevMode) {\n    if (isOptionsObj(itemValidatorOrOpts) && validator) {\n      console.warn(validatorsDroppedWithOptsWarning);\n    }\n  }\n  return (isOptionsObj(itemValidatorOrOpts) ? itemValidatorOrOpts.validators : validator) || null;\n}\n\n/**\n * Gets async validators from either an options object or given validators.\n */\nfunction pickAsyncValidators(\n  asyncValidator?: QdFormArrayAsyncValidator,\n  itemValidatorOrOpts?: QdFormArrayItemValidatorOrOpts\n): QdFormArrayAsyncValidator {\n  if (typeof ngDevMode === 'undefined' || ngDevMode) {\n    if (isOptionsObj(itemValidatorOrOpts) && asyncValidator) {\n      console.warn(validatorsDroppedWithOptsWarning);\n    }\n  }\n  return (isOptionsObj(itemValidatorOrOpts) ? itemValidatorOrOpts.asyncValidators : asyncValidator) || null;\n}\n\nfunction isOptionsObj(itemValidatorOrOpts?: QdFormArrayItemValidatorOrOpts): itemValidatorOrOpts is QdFormArrayOptions {\n  return itemValidatorOrOpts != null && !Array.isArray(itemValidatorOrOpts) && typeof itemValidatorOrOpts === 'object';\n}\n\nfunction removeListItem<T>(list: T[], el: T): void {\n  const index = list.indexOf(el);\n  if (index > -1) list.splice(index, 1);\n}\n\nconst validatorsDroppedWithOptsWarning = `\n  It looks like you're constructing using a QdFormControl with both an options argument and an\n  validators argument. Mixing these arguments will cause your validators in the argument to be dropped.\n  You should either put all your validators in the options object, or in separate validators\n  arguments. For example:\n\n  // Using validators arguments\n  fc = new QdFormControl(42, Validators.required, myAsyncValidator);\n\n  // Using AbstractControlOptions\n  fc = new QdFormControl(42, {validators: Validators.required, asyncValidators: myAV});\n\n  // Do NOT mix them: validators in additional argument will be dropped!\n  fc = new QdFormControl(42, {validators: Validators.required}, /* Oops! */ myAsyncValidator);\n`;\n"]}

package/esm2022/lib/forms/reactive-forms/controls/form-builder.mjs

@@ -0,0 +1,126 @@
+import { Injectable } from '@angular/core';
+import { UntypedFormArray, UntypedFormBuilder, UntypedFormControl, UntypedFormGroup } from '@angular/forms';
+import { pickItemAsyncValidators, pickItemValidators, QdFormArray } from './form-array';
+import { QdFormControl } from './form-control';
+import { QdFormGroup } from './form-group';
+import * as i0 from "@angular/core";
+export class QdFormBuilder extends UntypedFormBuilder {
+    group(controlsConfig, options = null) {
+        const controls = this._reduceControls(controlsConfig);
+        if (!options) {
+            return new QdFormGroup(controls);
+        }
+        let validators = null;
+        let asyncValidators = null;
+        let updateOn;
+        if (isAbstractControlOptions(options)) {
+            // `options` are `AbstractControlOptions`
+            validators = options.validators != null ? options.validators : null;
+            asyncValidators = options.asyncValidators != null ? options.asyncValidators : null;
+            updateOn = options.updateOn != null ? options.updateOn : undefined;
+        }
+        else {
+            // `options` are legacy form group options
+            validators = options['validator'] != null ? options['validator'] : null;
+            asyncValidators = options['asyncValidator'] != null ? options['asyncValidator'] : null;
+        }
+        return new QdFormGroup(controls, { asyncValidators, updateOn, validators });
+    }
+    /**
+     * @description
+     * Construct a new `QdFormControl` with the given state, validators and options.
+     *
+     * @param formState Initializes the control with an initial state value, or
+     * with an object that contains both a value and a disabled status.
+     *
+     * @param validatorOrOpts A synchronous validator function, or an array of
+     * such functions, or an `AbstractControlOptions` object that contains
+     * validation functions and a validation trigger.
+     *
+     * @param asyncValidator A single async validator or array of async validator
+     * functions.
+     */
+    control(formState, validatorOrOpts, asyncValidator) {
+        return new QdFormControl(formState, validatorOrOpts, asyncValidator);
+    }
+    /**
+     * Constructs a new `QdFormArray` from the given array of configurations,
+     * validators and options.
+     *
+     * @param controlsConfig An array of child controls or control configs. Each
+     * child control is given an index when it is registered.
+     *
+     * @param itemValidatorOrOpts A synchronous validator function, or an array of
+     * such functions to validate the single items, or an `QdFormArrayOptions` object
+     * that contains validation functions and a validation trigger.
+     *
+     * @param itemAsyncValidator A single async validator or array of async validator
+     * to validate the single items.
+     *
+     * @param validator A synchronous validator function, or an array of
+     * such functions.
+     *
+     * @param asyncValidator A single async validator or array of async validator
+     * functions.
+     */
+    array(controlsConfig, itemValidatorOrOpts, itemAsyncValidator, validator, asyncValidator) {
+        const itemValidators = pickItemValidators(itemValidatorOrOpts);
+        const itemAsyncValidators = pickItemAsyncValidators(itemAsyncValidator, itemValidatorOrOpts);
+        const controls = controlsConfig.map(c => this._createControl(c, itemValidators, itemAsyncValidators));
+        return new QdFormArray(controls, itemValidatorOrOpts, itemAsyncValidator, validator, asyncValidator);
+    }
+    /** @internal */
+    _reduceControls(controlsConfig) {
+        const controls = {};
+        Object.keys(controlsConfig).forEach(controlName => {
+            controls[controlName] = this._createControl(controlsConfig[controlName]);
+        });
+        return controls;
+    }
+    /** @internal */
+    _createControl(controlConfig, itemValidator = null, itemAsyncValidator = null) {
+        if (isFormControl(controlConfig) ||
+            isQdFormControl(controlConfig) ||
+            isFormGroup(controlConfig) ||
+            isQdFormGroup(controlConfig) ||
+            isFormArray(controlConfig) ||
+            isQdFormArray(controlConfig)) {
+            return controlConfig;
+        }
+        else if (Array.isArray(controlConfig)) {
+            const value = controlConfig[0];
+            const validator = controlConfig.length > 1 ? controlConfig[1] : null;
+            const asyncValidator = controlConfig.length > 2 ? controlConfig[2] : null;
+            return this.control(value, mergeValidators(validator, itemValidator), mergeValidators(asyncValidator, itemAsyncValidator));
+        }
+        else {
+            return this.control(controlConfig, itemValidator, itemAsyncValidator);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormBuilder, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormBuilder, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdFormBuilder, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+function mergeValidators(validator1, validator2) {
+    return [...getValidatorList(validator1), ...getValidatorList(validator2)];
+}
+function getValidatorList(validator) {
+    if (!validator)
+        return [];
+    return Array.isArray(validator) ? validator : [validator];
+}
+function isAbstractControlOptions(options) {
+    return (options.asyncValidators !== undefined ||
+        options.validators !== undefined ||
+        options.updateOn !== undefined);
+}
+const isFormControl = (control) => control instanceof UntypedFormControl;
+const isQdFormControl = (control) => control instanceof QdFormControl;
+const isFormGroup = (control) => control instanceof UntypedFormGroup;
+const isQdFormGroup = (control) => control instanceof QdFormGroup;
+const isFormArray = (control) => control instanceof UntypedFormArray;
+const isQdFormArray = (control) => control instanceof QdFormArray;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-builder.js","sourceRoot":"","sources":["../../../../../../../libs/qd-ui/src/lib/forms/reactive-forms/controls/form-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  AbstractControl,\n  AbstractControlOptions,\n  AsyncValidatorFn,\n  FormControlOptions,\n  UntypedFormArray,\n  UntypedFormBuilder,\n  UntypedFormControl,\n  UntypedFormGroup,\n  ValidatorFn\n} from '@angular/forms';\nimport {\n  pickItemAsyncValidators,\n  pickItemValidators,\n  QdFormArray,\n  QdFormArrayAsyncValidator,\n  QdFormArrayItemAsyncValidator,\n  QdFormArrayItemValidator,\n  QdFormArrayItemValidatorOrOpts,\n  QdFormArrayValidator\n} from './form-array';\nimport { QdFormControl } from './form-control';\nimport { QdFormGroup } from './form-group';\n\n@Injectable({ providedIn: 'root' })\nexport class QdFormBuilder extends UntypedFormBuilder {\n  /**\n   * @description\n   * Construct a new `QdFormGroup` instance.\n   *\n   * @param controlsConfig A collection of child controls. The key for each child is the name\n   * under which it is registered.\n   *\n   * @param options Configuration options object for the `QdFormGroup`. The object should have the\n   * the `AbstractControlOptions` type and might contain the following fields:\n   * * `validators`: A synchronous validator function, or an array of validator functions\n   * * `asyncValidators`: A single async validator or array of async validator functions\n   * * `updateOn`: The event upon which the control should be updated (options: 'change' | 'blur' |\n   * submit')\n   */\n  override group(controlsConfig: { [key: string]: any }, options?: AbstractControlOptions | null): QdFormGroup;\n\n  /**\n   * @description\n   * Construct a new `QdFormGroup` instance.\n   *\n   * @deprecated This API is not typesafe and can result in issues with Closure Compiler renaming.\n   * Use the `QdFormBuilder#group` overload with `AbstractControlOptions` instead.\n   * Note that `AbstractControlOptions` expects `validators` and `asyncValidators` to be valid\n   * validators. If you have custom validators, make sure their validation function parameter is\n   * `AbstractControl` and not a sub-class, such as `QdFormGroup`. These functions will be called with\n   * an object of type `AbstractControl` and that cannot be automatically downcast to a subclass, so\n   * TypeScript sees this as an error. For example, change the `(group: QdFormGroup) =>\n   * ValidationErrors|null` signature to be `(group: AbstractControl) => ValidationErrors|null`.\n   *\n   * @param controlsConfig A collection of child controls. The key for each child is the name\n   * under which it is registered.\n   *\n   * @param options Configuration options object for the `QdFormGroup`. The legacy configuration\n   * object consists of:\n   * * `validator`: A synchronous validator function, or an array of validator functions\n   * * `asyncValidator`: A single async validator or array of async validator functions\n   * Note: the legacy format is deprecated and might be removed in one of the next major versions\n   * of Angular.\n   */\n  override group(controlsConfig: { [key: string]: any }, options: { [key: string]: any }): QdFormGroup;\n\n  override group(\n    controlsConfig: { [key: string]: any },\n    options: AbstractControlOptions | { [key: string]: any } | null = null\n  ): QdFormGroup {\n    const controls = this._reduceControls(controlsConfig);\n\n    if (!options) {\n      return new QdFormGroup(controls);\n    }\n\n    let validators: ValidatorFn | ValidatorFn[] | null = null;\n    let asyncValidators: AsyncValidatorFn | AsyncValidatorFn[] | null = null;\n    let updateOn;\n\n    if (isAbstractControlOptions(options)) {\n      // `options` are `AbstractControlOptions`\n      validators = options.validators != null ? options.validators : null;\n      asyncValidators = options.asyncValidators != null ? options.asyncValidators : null;\n      updateOn = options.updateOn != null ? options.updateOn : undefined;\n    } else {\n      // `options` are legacy form group options\n      validators = options['validator'] != null ? options['validator'] : null;\n      asyncValidators = options['asyncValidator'] != null ? options['asyncValidator'] : null;\n    }\n\n    return new QdFormGroup(controls, { asyncValidators, updateOn, validators });\n  }\n\n  /**\n   * @description\n   * Construct a new `QdFormControl` with the given state, validators and options.\n   *\n   * @param formState Initializes the control with an initial state value, or\n   * with an object that contains both a value and a disabled status.\n   *\n   * @param validatorOrOpts A synchronous validator function, or an array of\n   * such functions, or an `AbstractControlOptions` object that contains\n   * validation functions and a validation trigger.\n   *\n   * @param asyncValidator A single async validator or array of async validator\n   * functions.\n   */\n  override control<T>(\n    formState: any,\n    validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions | null,\n    asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null\n  ): QdFormControl<T> {\n    return new QdFormControl<T>(formState, validatorOrOpts, asyncValidator);\n  }\n\n  /**\n   * Constructs a new `QdFormArray` from the given array of configurations,\n   * validators and options.\n   *\n   * @param controlsConfig An array of child controls or control configs. Each\n   * child control is given an index when it is registered.\n   *\n   * @param itemValidatorOrOpts A synchronous validator function, or an array of\n   * such functions to validate the single items, or an `QdFormArrayOptions` object\n   * that contains validation functions and a validation trigger.\n   *\n   * @param itemAsyncValidator A single async validator or array of async validator\n   * to validate the single items.\n   *\n   * @param validator A synchronous validator function, or an array of\n   * such functions.\n   *\n   * @param asyncValidator A single async validator or array of async validator\n   * functions.\n   */\n  override array<T>(\n    controlsConfig: any[],\n    itemValidatorOrOpts?: QdFormArrayItemValidatorOrOpts,\n    itemAsyncValidator?: QdFormArrayItemAsyncValidator,\n    validator?: QdFormArrayValidator,\n    asyncValidator?: QdFormArrayAsyncValidator\n  ): QdFormArray<T> {\n    const itemValidators = pickItemValidators(itemValidatorOrOpts);\n    const itemAsyncValidators = pickItemAsyncValidators(itemAsyncValidator, itemValidatorOrOpts);\n    const controls = controlsConfig.map(c => this._createControl(c, itemValidators, itemAsyncValidators));\n    return new QdFormArray<T>(controls, itemValidatorOrOpts, itemAsyncValidator, validator, asyncValidator);\n  }\n\n  /** @internal */\n  _reduceControls(controlsConfig: { [k: string]: any }): { [key: string]: AbstractControl } {\n    const controls: { [key: string]: AbstractControl } = {};\n    Object.keys(controlsConfig).forEach(controlName => {\n      controls[controlName] = this._createControl(controlsConfig[controlName]);\n    });\n    return controls;\n  }\n\n  /** @internal */\n  _createControl(\n    controlConfig: any,\n    itemValidator: QdFormArrayItemValidator = null,\n    itemAsyncValidator: QdFormArrayItemAsyncValidator = null\n  ): AbstractControl {\n    if (\n      isFormControl(controlConfig) ||\n      isQdFormControl(controlConfig) ||\n      isFormGroup(controlConfig) ||\n      isQdFormGroup(controlConfig) ||\n      isFormArray(controlConfig) ||\n      isQdFormArray(controlConfig)\n    ) {\n      return controlConfig;\n    } else if (Array.isArray(controlConfig)) {\n      const value = controlConfig[0];\n      const validator: ValidatorFn = controlConfig.length > 1 ? controlConfig[1] : null;\n      const asyncValidator: AsyncValidatorFn = controlConfig.length > 2 ? controlConfig[2] : null;\n      return this.control(\n        value,\n        mergeValidators<ValidatorFn>(validator, itemValidator),\n        mergeValidators<AsyncValidatorFn>(asyncValidator, itemAsyncValidator)\n      );\n    } else {\n      return this.control(controlConfig, itemValidator, itemAsyncValidator);\n    }\n  }\n}\n\nfunction mergeValidators<T extends ValidatorFn | AsyncValidatorFn>(\n  validator1: T | T[] | null,\n  validator2: T | T[] | null\n): T[] {\n  return [...getValidatorList(validator1), ...getValidatorList(validator2)];\n}\n\nfunction getValidatorList<T extends ValidatorFn | AsyncValidatorFn>(validator: T | T[] | null): T[] {\n  if (!validator) return [];\n\n  return Array.isArray(validator) ? validator : [validator];\n}\n\nfunction isAbstractControlOptions(\n  options: AbstractControlOptions | { [key: string]: any }\n): options is AbstractControlOptions {\n  return (\n    (options as AbstractControlOptions).asyncValidators !== undefined ||\n    (options as AbstractControlOptions).validators !== undefined ||\n    (options as AbstractControlOptions).updateOn !== undefined\n  );\n}\n\nconst isFormControl = (control: unknown): control is UntypedFormControl => control instanceof UntypedFormControl;\nconst isQdFormControl = (control: unknown): control is QdFormControl<any> => control instanceof QdFormControl;\n\nconst isFormGroup = (control: unknown): control is UntypedFormGroup => control instanceof UntypedFormGroup;\nconst isQdFormGroup = (control: unknown): control is QdFormGroup => control instanceof QdFormGroup;\n\nconst isFormArray = (control: unknown): control is UntypedFormArray => control instanceof UntypedFormArray;\nconst isQdFormArray = (control: unknown): control is QdFormArray<any> => control instanceof QdFormArray;\n"]}

package/esm2022/lib/forms/reactive-forms/controls/form-control.mjs

@@ -0,0 +1,61 @@
+// @ts-strict-ignore
+import { UntypedFormControl } from '@angular/forms';
+export class QdFormControl extends UntypedFormControl {
+    maxLength;
+    validatorList;
+    constructor(formState, validatorOrOpts, asyncValidator) {
+        super(formState, validatorOrOpts, asyncValidator);
+        this.validatorList = this.getValidatorList(validatorOrOpts);
+        this.setPropsFromValidatorList();
+    }
+    getValidatorList(validatorOrOpts) {
+        const validator = isOptionsObj(validatorOrOpts) ? validatorOrOpts.validators : validatorOrOpts;
+        if (!validator)
+            return [];
+        return Array.isArray(validator) ? validator : [validator];
+    }
+    setPropsFromValidatorList() {
+        let maxLength;
+        this.validatorList.forEach((validatorFn) => {
+            if (validatorFn.maxLength) {
+                maxLength = validatorFn.maxLength;
+            }
+        });
+        this.maxLength = maxLength;
+    }
+    setValidators(validators) {
+        this.validatorList = this.getValidatorList(validators);
+        this.setPropsFromValidatorList();
+        super.setValidators(validators);
+    }
+    addValidators(validators) {
+        this.validatorList.push(...this.getValidatorList(validators));
+        this.setPropsFromValidatorList();
+        super.addValidators(validators);
+    }
+    removeValidators(validators) {
+        const validatorsToRemove = this.getValidatorList(validators);
+        validatorsToRemove.forEach(validatorToRemove => {
+            const index = this.validatorList.indexOf(validatorToRemove);
+            if (index > -1)
+                this.validatorList.splice(index, 1);
+        });
+        this.setPropsFromValidatorList();
+        super.removeValidators(validators);
+    }
+    clearValidators() {
+        this.validatorList = [];
+        this.setPropsFromValidatorList();
+        super.clearValidators();
+    }
+    hasMaxLength() {
+        return this.maxLength !== undefined;
+    }
+    getMaxLengthOrUndefined() {
+        return this.maxLength;
+    }
+}
+function isOptionsObj(validatorOrOpts) {
+    return validatorOrOpts != null && !Array.isArray(validatorOrOpts) && typeof validatorOrOpts === 'object';
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/forms/reactive-forms/controls/form-group.mjs

@@ -0,0 +1,4 @@
+import { UntypedFormGroup } from '@angular/forms';
+export class QdFormGroup extends UntypedFormGroup {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1ncm91cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcWQtdWkvc3JjL2xpYi9mb3Jtcy9yZWFjdGl2ZS1mb3Jtcy9jb250cm9scy9mb3JtLWdyb3VwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRWxELE1BQU0sT0FBTyxXQUFZLFNBQVEsZ0JBQWdCO0NBQUciLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVbnR5cGVkRm9ybUdyb3VwIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuXG5leHBvcnQgY2xhc3MgUWRGb3JtR3JvdXAgZXh0ZW5kcyBVbnR5cGVkRm9ybUdyb3VwIHt9XG4iXX0=