@ethlete/query 5.16.0 → 5.16.1

package/esm2022/lib/query-form/query-form.mjs

@@ -0,0 +1,379 @@
+import { NgZone, assertInInjectionContext, inject, isDevMode } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { FormGroup } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+import { ET_PROPERTY_REMOVED, RouterStateService, clone, createDestroy, equal } from '@ethlete/core';
+import { BehaviorSubject, Subject, debounceTime, map, merge, of, switchMap, takeUntil, tap, timer } from 'rxjs';
+import { transformToBoolean, transformToNumber } from './query-form.utils';
+const ET_ARR_PREFIX = 'ET_ARR__';
+export class QueryField {
+    get control() {
+        return this.data.control;
+    }
+    constructor(data) {
+        this.data = data;
+    }
+}
+const IGNORED_FILTER_COUNT_FIELDS = ['page', 'skip', 'take', 'limit', 'sort', 'sortBy', 'sortOrder', 'query', 'search'];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class QueryForm {
+    get _formValue() {
+        return this.form.getRawValue();
+    }
+    get _form() {
+        return this.form;
+    }
+    get controls() {
+        return this.form.controls;
+    }
+    get value() {
+        return this._changes$.value.currentValue;
+    }
+    get defaultFormValue() {
+        return Object.entries(this._defaultValues).reduce((acc, [key]) => {
+            acc[key] = this._getDefaultValue(key);
+            return acc;
+        }, {});
+    }
+    // with prefix eg. page should become ${prefix}-page
+    constructor(_fields, _options) {
+        this._fields = _fields;
+        this._options = _options;
+        this._destroy$ = createDestroy();
+        this._unobserveTrigger$ = new Subject();
+        this._router = inject(Router);
+        this._activatedRoute = inject(ActivatedRoute);
+        this._defaultValues = this._extractDefaultValues();
+        this._routerStateService = inject(RouterStateService);
+        this._zone = inject(NgZone);
+        this._didValueChanges$ = new Subject();
+        this._isObserving = false;
+        this._skipNextResets = false;
+        /**
+         * The angular form group that contains all the fields.
+         *
+         * **Do not** use any of the following methods on this form group:
+         * - `setValue`: Use `QueryForm.setValue` instead.
+         * - `patchValue`: Use `QueryForm.patchValue` instead.
+         * - `valueChanges`: Use `QueryForm.changes$` instead.
+         * - `value`: Use `QueryForm.value` instead.
+         * - `controls`: Use `QueryForm.controls` instead.
+         */
+        this.form = this._setupFormGroup();
+        this._lastFormValue$ = new BehaviorSubject(null);
+        this._currentFormValue$ = new BehaviorSubject(this._formValue);
+        this._changes$ = new BehaviorSubject({
+            previousValue: null,
+            currentValue: this.form.getRawValue(),
+        });
+        this.changes$ = this._changes$.asObservable();
+        this.currentValue$ = this._changes$.pipe(map(({ currentValue }) => currentValue));
+        this.previousValue$ = this._changes$.pipe(map(({ previousValue }) => previousValue));
+        this.changes = toSignal(this.changes$);
+        this.currentValue = toSignal(this.currentValue$);
+        this.previousValue = toSignal(this.previousValue$);
+        /**
+         * The number of active filters.
+         *
+         * Excludes the following fields by default:
+         * - `page`
+         * - `skip`
+         * - `take`
+         * - `limit`
+         * - `sort`
+         * - `sortBy`
+         * - `sortOrder`
+         * - `query`
+         * - `search`
+         */
+        this.activeFilterCount$ = this.changes$.pipe(map(({ currentValue }) => Object.entries(currentValue)
+            .map(([key, value]) => {
+            if (IGNORED_FILTER_COUNT_FIELDS.includes(key) || this._fields[key]?.data.skipInFilterCount) {
+                return true;
+            }
+            return this._isDefaultValue(key, value);
+        })
+            .filter((v) => v === false).length));
+        assertInInjectionContext(QueryForm);
+    }
+    observe(options) {
+        if (this._isObserving) {
+            if (isDevMode()) {
+                console.warn('QueryForm.observe() was called multiple times. This is not supported.');
+            }
+            return this;
+        }
+        this._isObserving = true;
+        if (options?.syncOnNavigation !== false) {
+            const didChanges = this.setFormValueFromUrlQueryParams({
+                queryParams: this._routerStateService.queryParams,
+            });
+            if (didChanges) {
+                this._handleFormChange(true);
+            }
+        }
+        merge(...Object.values(this._fields).map((field) => field.control.valueChanges), this._didValueChanges$)
+            .pipe(debounceTime(0), tap(() => {
+            this._handleFormChange();
+        }), takeUntil(this._destroy$), takeUntil(this._unobserveTrigger$))
+            .subscribe();
+        let changedFieldsInLastResetLoop = [];
+        let currentUniqueChangedFields = [];
+        this._currentFormValue$
+            .pipe(map((currentValue) => {
+            return {
+                previousValue: clone(this._lastFormValue$.value),
+                currentValue: clone(currentValue),
+            };
+        }), tap(({ currentValue, previousValue }) => {
+            if (options?.writeToQueryParams !== false) {
+                this._syncViaUrlQueryParams(currentValue, options?.replaceUrl);
+            }
+            const didResetValues = this._skipNextResets
+                ? false
+                : this._handleQueryFormResets(previousValue ?? null, currentValue);
+            this._skipNextResets = false;
+            const changedFields = Object.keys(currentValue).filter((key) => !equal(previousValue?.[key], currentValue[key]));
+            if (changedFieldsInLastResetLoop.length) {
+                changedFields.push(...changedFieldsInLastResetLoop);
+                changedFieldsInLastResetLoop = [];
+            }
+            if (didResetValues) {
+                this._didValueChanges$.next(true);
+                changedFieldsInLastResetLoop = changedFields;
+            }
+            currentUniqueChangedFields = [...new Set(changedFields)];
+        }), switchMap(({ currentValue, previousValue }) => {
+            if (changedFieldsInLastResetLoop.length)
+                return of(null).pipe(map(() => ({ currentValue, previousValue })));
+            const debounceValues = currentUniqueChangedFields.map((key) => {
+                const field = this._fields[key];
+                if (!field)
+                    return null;
+                if (field.data.disableDebounceIfFalsy === true && !currentValue[key]) {
+                    return null;
+                }
+                return field.data.debounce ?? null;
+            });
+            currentUniqueChangedFields = [];
+            if (debounceValues.some((v) => v === null) || !debounceValues.length) {
+                return of(null).pipe(map(() => ({ currentValue, previousValue })));
+            }
+            const shortestDebounceTime = Math.min(...debounceValues.filter((v) => v !== null));
+            return timer(shortestDebounceTime).pipe(map(() => ({ currentValue, previousValue })));
+        }), tap(({ currentValue, previousValue }) => {
+            if (changedFieldsInLastResetLoop.length)
+                return;
+            this._changes$.next({
+                previousValue: previousValue ?? null,
+                currentValue: currentValue,
+            });
+        }), takeUntil(this._destroy$), takeUntil(this._unobserveTrigger$))
+            .subscribe();
+        if (options?.syncOnNavigation !== false) {
+            this._routerStateService.queryParamChanges$
+                .pipe(takeUntil(this._destroy$), takeUntil(this._unobserveTrigger$), tap((changes) => {
+                const didValueChanges = this.setFormValueFromUrlQueryParams({ queryParams: changes });
+                if (didValueChanges) {
+                    this._didValueChanges$.next(true);
+                }
+            }))
+                .subscribe();
+        }
+        return this;
+    }
+    _handleQueryFormResets(previousValue, currentValue) {
+        let didResetValues = false;
+        for (const formFieldKey in this._fields) {
+            const field = this._fields[formFieldKey];
+            if (!field)
+                continue;
+            const resets = field.data.isResetBy;
+            if (!resets)
+                continue;
+            const resetConditionKeys = Array.isArray(resets) ? resets : [resets];
+            for (const resetConditionKey of resetConditionKeys) {
+                if (!(resetConditionKey in this._fields)) {
+                    if (isDevMode()) {
+                        console.warn(`The field "${resetConditionKey}" is not defined in the QueryForm. Is it a typo?`, this);
+                    }
+                    continue;
+                }
+                if (previousValue &&
+                    currentValue &&
+                    !equal(previousValue[resetConditionKey], currentValue[resetConditionKey])) {
+                    const defaultValueForKeyToReset = this._getDefaultValue(formFieldKey);
+                    const currentValueForKeyToReset = currentValue[formFieldKey];
+                    if (equal(defaultValueForKeyToReset, currentValueForKeyToReset)) {
+                        continue;
+                    }
+                    this.form.controls[formFieldKey].setValue(defaultValueForKeyToReset);
+                    didResetValues = true;
+                    break;
+                }
+            }
+        }
+        return didResetValues;
+    }
+    unobserve() {
+        this._unobserveTrigger$.next(true);
+    }
+    setFormValueFromUrlQueryParams(options) {
+        let didValueChanges = false;
+        for (const [key, field] of Object.entries(this._fields)) {
+            const value = options.queryParams[this._transformKeyToQueryParam(key)];
+            const valueDoesNotExist = value === undefined;
+            if (valueDoesNotExist)
+                continue;
+            const valueGotRemoved = value === ET_PROPERTY_REMOVED;
+            if (valueGotRemoved) {
+                field.control.setValue(this._getDefaultValue(key), { emitEvent: false });
+                didValueChanges = true;
+                continue;
+            }
+            let deserializedValue = value;
+            if (field.data.queryParamToValueTransformFn) {
+                deserializedValue = field.data.queryParamToValueTransformFn(value);
+            }
+            else if (typeof this._getDefaultValue(key) === 'number' || !isNaN(Number(value))) {
+                deserializedValue = transformToNumber(value);
+            }
+            else if (typeof this._getDefaultValue(key) === 'boolean' || value === 'true' || value === 'false') {
+                deserializedValue = transformToBoolean(value);
+            }
+            const valueIsEqualToCurrent = equal(deserializedValue, field.control.value);
+            if (valueIsEqualToCurrent)
+                continue;
+            field.control.setValue(deserializedValue, { emitEvent: false });
+            didValueChanges = true;
+        }
+        return didValueChanges;
+    }
+    setValue(value, options) {
+        this._form._setValue(value, options);
+        if (options?.skipResets) {
+            this._skipNextResets = true;
+        }
+    }
+    patchValue(value, options) {
+        this._form._patchValue(value, options);
+        if (options?.skipResets) {
+            this._skipNextResets = true;
+        }
+    }
+    resetFieldToDefault(key, options) {
+        const defaultValue = this._getDefaultValue(key);
+        this.form.controls[key].setValue(defaultValue);
+        if (options?.skipResets) {
+            this._skipNextResets = true;
+        }
+    }
+    resetFieldsToDefault(keys, options) {
+        const defaults = keys.reduce((acc, key) => {
+            acc[key] = this._getDefaultValue(key);
+            return acc;
+        }, {});
+        this.patchValue(defaults);
+        if (options?.skipResets) {
+            this._skipNextResets = true;
+        }
+    }
+    resetAllFieldsToDefault(options) {
+        const keys = Object.keys(this._fields);
+        if (options?.skipFields) {
+            for (const key of options.skipFields) {
+                const index = keys.indexOf(key);
+                if (index !== -1) {
+                    keys.splice(index, 1);
+                }
+            }
+        }
+        this.resetFieldsToDefault(keys, options);
+    }
+    _getDefaultValue(key) {
+        const val = this._defaultValues[key];
+        if (typeof val === 'string' && val.startsWith(ET_ARR_PREFIX)) {
+            return JSON.parse(val.slice(ET_ARR_PREFIX.length));
+        }
+        return val ?? null;
+    }
+    _transformKeyToQueryParam(key) {
+        if (!this._options?.queryParamPrefix)
+            return key;
+        const prefix = typeof this._options?.queryParamPrefix === 'string'
+            ? this._options.queryParamPrefix
+            : this._options.queryParamPrefix();
+        return `${prefix}-${key}`;
+    }
+    _isDefaultValue(key, value) {
+        const normalizedValue = Array.isArray(value) ? `${ET_ARR_PREFIX}${JSON.stringify(value)}` : value;
+        return this._getDefaultValue(key) === normalizedValue;
+    }
+    _setupFormGroup() {
+        const group = new FormGroup({});
+        for (const [key, field] of Object.entries(this._fields)) {
+            group.addControl(key, field.control);
+        }
+        group._patchValue = group.patchValue;
+        group._setValue = group.setValue;
+        group.patchValue = this.patchValue.bind(this);
+        group.setValue = this.setValue.bind(this);
+        return group;
+    }
+    _extractDefaultValues() {
+        const defaultValues = {};
+        for (const [key, field] of Object.entries(this._fields)) {
+            const value = field.data.defaultValue !== undefined ? field.data.defaultValue : field.control.value;
+            if (Array.isArray(value)) {
+                defaultValues[key] = `${ET_ARR_PREFIX}${JSON.stringify(value)}`;
+            }
+            else {
+                defaultValues[key] = value;
+            }
+        }
+        return defaultValues;
+    }
+    _syncViaUrlQueryParams(values, replaceUrl) {
+        const queryParams = { ...clone(this._activatedRoute.snapshot.queryParams) };
+        for (const [key, value] of Object.entries(values)) {
+            const queryParamKey = this._transformKeyToQueryParam(key);
+            const field = this._fields[key];
+            if (!field) {
+                continue;
+            }
+            const isDefault = this._isDefaultValue(key, value);
+            const writeDefaultToUrl = field.data.appendDefaultValueToUrl === true;
+            const writeToUrl = field.data.appendToUrl !== false;
+            if (!writeToUrl || (isDefault && !writeDefaultToUrl)) {
+                queryParams[queryParamKey] = undefined;
+            }
+            else {
+                queryParams[queryParamKey] = field.data.valueToQueryParamTransformFn
+                    ? field.data.valueToQueryParamTransformFn?.(value)
+                    : value;
+            }
+        }
+        this._zone.run(() => {
+            this._router.navigate([], {
+                queryParams,
+                replaceUrl,
+                queryParamsHandling: 'merge',
+            });
+        });
+    }
+    _handleFormChange(forceOverwrite = false) {
+        const currentVal = clone(this._currentFormValue$.value);
+        const newVal = clone(this._formValue);
+        if (equal(currentVal, newVal)) {
+            return;
+        }
+        if (forceOverwrite) {
+            this._lastFormValue$.next(newVal);
+        }
+        else {
+            this._lastFormValue$.next(currentVal);
+        }
+        this._currentFormValue$.next(newVal);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-form.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/query-form/query-form.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgZone, assertInInjectionContext, inject, isDevMode } from '@angular/core';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport { FormGroup } from '@angular/forms';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { ET_PROPERTY_REMOVED, RouterStateService, clone, createDestroy, equal } from '@ethlete/core';\nimport { BehaviorSubject, Subject, debounceTime, map, merge, of, switchMap, takeUntil, tap, timer } from 'rxjs';\nimport {\n  QueryFieldOptions,\n  QueryFormGroup,\n  QueryFormGroupControls,\n  QueryFormObserveOptions,\n  QueryFormValue,\n  QueryFormValueEvent,\n  QueryFormWriteOptions,\n} from './query-form.types';\nimport { transformToBoolean, transformToNumber } from './query-form.utils';\n\nconst ET_ARR_PREFIX = 'ET_ARR__';\n\nexport class QueryField<T> {\n  get control() {\n    return this.data.control;\n  }\n\n  constructor(public data: QueryFieldOptions<T>) {}\n}\n\nconst IGNORED_FILTER_COUNT_FIELDS = ['page', 'skip', 'take', 'limit', 'sort', 'sortBy', 'sortOrder', 'query', 'search'];\n\nexport interface QueryFormOptions {\n  /**\n   * A prefix to use for the query parameters. This is useful when you have multiple query forms on the same page.\n   */\n  queryParamPrefix?: string | (() => string);\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyQueryForm = QueryForm<any>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class QueryForm<T extends Record<string, QueryField<any>>> {\n  private readonly _destroy$ = createDestroy();\n  private readonly _unobserveTrigger$ = new Subject<boolean>();\n  private readonly _router = inject(Router);\n  private readonly _activatedRoute = inject(ActivatedRoute);\n  private readonly _defaultValues = this._extractDefaultValues();\n  private readonly _routerStateService = inject(RouterStateService);\n  private readonly _zone = inject(NgZone);\n  private readonly _didValueChanges$ = new Subject<boolean>();\n\n  private _isObserving = false;\n  private _skipNextResets = false;\n\n  /**\n   * The angular form group that contains all the fields.\n   *\n   * **Do not** use any of the following methods on this form group:\n   * - `setValue`: Use `QueryForm.setValue` instead.\n   * - `patchValue`: Use `QueryForm.patchValue` instead.\n   * - `valueChanges`: Use `QueryForm.changes$` instead.\n   * - `value`: Use `QueryForm.value` instead.\n   * - `controls`: Use `QueryForm.controls` instead.\n   */\n  readonly form = this._setupFormGroup();\n\n  private readonly _lastFormValue$ = new BehaviorSubject<QueryFormValue<T> | null>(null);\n  private readonly _currentFormValue$ = new BehaviorSubject<QueryFormValue<T>>(this._formValue);\n\n  private get _formValue() {\n    return this.form.getRawValue() as QueryFormValue<T>;\n  }\n\n  private get _form() {\n    return this.form as unknown as QueryFormGroup;\n  }\n\n  private readonly _changes$ = new BehaviorSubject<QueryFormValueEvent<T>>({\n    previousValue: null,\n    currentValue: this.form.getRawValue() as QueryFormValue<T>,\n  });\n\n  readonly changes$ = this._changes$.asObservable();\n  readonly currentValue$ = this._changes$.pipe(map(({ currentValue }) => currentValue));\n  readonly previousValue$ = this._changes$.pipe(map(({ previousValue }) => previousValue));\n\n  readonly changes = toSignal(this.changes$);\n  readonly currentValue = toSignal(this.currentValue$);\n  readonly previousValue = toSignal(this.previousValue$);\n\n  /**\n   * The number of active filters.\n   *\n   * Excludes the following fields by default:\n   * - `page`\n   * - `skip`\n   * - `take`\n   * - `limit`\n   * - `sort`\n   * - `sortBy`\n   * - `sortOrder`\n   * - `query`\n   * - `search`\n   */\n  readonly activeFilterCount$ = this.changes$.pipe(\n    map(\n      ({ currentValue }) =>\n        Object.entries(currentValue)\n          .map(([key, value]) => {\n            if (IGNORED_FILTER_COUNT_FIELDS.includes(key) || this._fields[key]?.data.skipInFilterCount) {\n              return true;\n            }\n\n            return this._isDefaultValue(key, value);\n          })\n          .filter((v) => v === false).length,\n    ),\n  );\n\n  get controls() {\n    return this.form.controls;\n  }\n\n  get value() {\n    return this._changes$.value.currentValue;\n  }\n\n  get defaultFormValue() {\n    return Object.entries(this._defaultValues).reduce((acc, [key]) => {\n      acc[key as keyof QueryFormValue<T>] = this._getDefaultValue(key);\n\n      return acc;\n    }, {} as QueryFormValue<T>);\n  }\n\n  // with prefix eg. page should become ${prefix}-page\n  constructor(\n    private _fields: T,\n    private _options?: QueryFormOptions,\n  ) {\n    assertInInjectionContext(QueryForm);\n  }\n\n  observe(options?: QueryFormObserveOptions) {\n    if (this._isObserving) {\n      if (isDevMode()) {\n        console.warn('QueryForm.observe() was called multiple times. This is not supported.');\n      }\n      return this;\n    }\n\n    this._isObserving = true;\n\n    if (options?.syncOnNavigation !== false) {\n      const didChanges = this.setFormValueFromUrlQueryParams({\n        queryParams: this._routerStateService.queryParams,\n      });\n\n      if (didChanges) {\n        this._handleFormChange(true);\n      }\n    }\n\n    merge(...Object.values(this._fields).map((field) => field.control.valueChanges), this._didValueChanges$)\n      .pipe(\n        debounceTime(0),\n        tap(() => {\n          this._handleFormChange();\n        }),\n        takeUntil(this._destroy$),\n        takeUntil(this._unobserveTrigger$),\n      )\n      .subscribe();\n\n    let changedFieldsInLastResetLoop: string[] = [];\n    let currentUniqueChangedFields: string[] = [];\n\n    this._currentFormValue$\n      .pipe(\n        map((currentValue) => {\n          return {\n            previousValue: clone(this._lastFormValue$.value),\n            currentValue: clone(currentValue),\n          };\n        }),\n        tap(({ currentValue, previousValue }) => {\n          if (options?.writeToQueryParams !== false) {\n            this._syncViaUrlQueryParams(currentValue, options?.replaceUrl);\n          }\n\n          const didResetValues = this._skipNextResets\n            ? false\n            : this._handleQueryFormResets(previousValue ?? null, currentValue);\n\n          this._skipNextResets = false;\n\n          const changedFields = Object.keys(currentValue).filter(\n            (key) => !equal(previousValue?.[key], currentValue[key]),\n          );\n\n          if (changedFieldsInLastResetLoop.length) {\n            changedFields.push(...changedFieldsInLastResetLoop);\n            changedFieldsInLastResetLoop = [];\n          }\n\n          if (didResetValues) {\n            this._didValueChanges$.next(true);\n            changedFieldsInLastResetLoop = changedFields;\n          }\n\n          currentUniqueChangedFields = [...new Set(changedFields)];\n        }),\n        switchMap(({ currentValue, previousValue }) => {\n          if (changedFieldsInLastResetLoop.length) return of(null).pipe(map(() => ({ currentValue, previousValue })));\n\n          const debounceValues = currentUniqueChangedFields.map((key) => {\n            const field = this._fields[key];\n\n            if (!field) return null;\n\n            if (field.data.disableDebounceIfFalsy === true && !currentValue[key]) {\n              return null;\n            }\n\n            return field.data.debounce ?? null;\n          });\n\n          currentUniqueChangedFields = [];\n\n          if (debounceValues.some((v) => v === null) || !debounceValues.length) {\n            return of(null).pipe(map(() => ({ currentValue, previousValue })));\n          }\n\n          const shortestDebounceTime = Math.min(...debounceValues.filter((v): v is number => v !== null));\n\n          return timer(shortestDebounceTime).pipe(map(() => ({ currentValue, previousValue })));\n        }),\n        tap(({ currentValue, previousValue }) => {\n          if (changedFieldsInLastResetLoop.length) return;\n\n          this._changes$.next({\n            previousValue: previousValue ?? null,\n            currentValue: currentValue,\n          });\n        }),\n        takeUntil(this._destroy$),\n        takeUntil(this._unobserveTrigger$),\n      )\n      .subscribe();\n\n    if (options?.syncOnNavigation !== false) {\n      this._routerStateService.queryParamChanges$\n        .pipe(\n          takeUntil(this._destroy$),\n          takeUntil(this._unobserveTrigger$),\n          tap((changes) => {\n            const didValueChanges = this.setFormValueFromUrlQueryParams({ queryParams: changes });\n\n            if (didValueChanges) {\n              this._didValueChanges$.next(true);\n            }\n          }),\n        )\n        .subscribe();\n    }\n\n    return this;\n  }\n\n  private _handleQueryFormResets(previousValue: QueryFormValue<T> | null, currentValue: QueryFormValue<T>) {\n    let didResetValues = false;\n\n    for (const formFieldKey in this._fields) {\n      const field = this._fields[formFieldKey];\n\n      if (!field) continue;\n\n      const resets = field.data.isResetBy;\n\n      if (!resets) continue;\n\n      const resetConditionKeys = Array.isArray(resets) ? resets : [resets];\n\n      for (const resetConditionKey of resetConditionKeys) {\n        if (!(resetConditionKey in this._fields)) {\n          if (isDevMode()) {\n            console.warn(`The field \"${resetConditionKey}\" is not defined in the QueryForm. Is it a typo?`, this);\n          }\n\n          continue;\n        }\n\n        if (\n          previousValue &&\n          currentValue &&\n          !equal(previousValue[resetConditionKey], currentValue[resetConditionKey])\n        ) {\n          const defaultValueForKeyToReset = this._getDefaultValue(formFieldKey);\n          const currentValueForKeyToReset = currentValue[formFieldKey];\n\n          if (equal(defaultValueForKeyToReset, currentValueForKeyToReset)) {\n            continue;\n          }\n\n          this.form.controls[formFieldKey].setValue(defaultValueForKeyToReset);\n\n          didResetValues = true;\n\n          break;\n        }\n      }\n    }\n\n    return didResetValues;\n  }\n\n  unobserve() {\n    this._unobserveTrigger$.next(true);\n  }\n\n  setFormValueFromUrlQueryParams(options: { queryParams: Record<string, unknown> }) {\n    let didValueChanges = false;\n\n    for (const [key, field] of Object.entries(this._fields)) {\n      const value = options.queryParams[this._transformKeyToQueryParam(key)];\n\n      const valueDoesNotExist = value === undefined;\n\n      if (valueDoesNotExist) continue;\n\n      const valueGotRemoved = value === ET_PROPERTY_REMOVED;\n\n      if (valueGotRemoved) {\n        field.control.setValue(this._getDefaultValue(key), { emitEvent: false });\n        didValueChanges = true;\n\n        continue;\n      }\n      let deserializedValue = value;\n\n      if (field.data.queryParamToValueTransformFn) {\n        deserializedValue = field.data.queryParamToValueTransformFn(value);\n      } else if (typeof this._getDefaultValue(key) === 'number' || !isNaN(Number(value))) {\n        deserializedValue = transformToNumber(value);\n      } else if (typeof this._getDefaultValue(key) === 'boolean' || value === 'true' || value === 'false') {\n        deserializedValue = transformToBoolean(value);\n      }\n\n      const valueIsEqualToCurrent = equal(deserializedValue, field.control.value);\n\n      if (valueIsEqualToCurrent) continue;\n\n      field.control.setValue(deserializedValue, { emitEvent: false });\n      didValueChanges = true;\n    }\n\n    return didValueChanges;\n  }\n\n  setValue(value: QueryFormValue<T>, options?: QueryFormWriteOptions) {\n    this._form._setValue(value, options);\n\n    if (options?.skipResets) {\n      this._skipNextResets = true;\n    }\n  }\n\n  patchValue(value: Partial<QueryFormValue<T>>, options?: QueryFormWriteOptions) {\n    this._form._patchValue(value, options);\n\n    if (options?.skipResets) {\n      this._skipNextResets = true;\n    }\n  }\n\n  resetFieldToDefault(key: keyof QueryFormValue<T>, options?: QueryFormWriteOptions) {\n    const defaultValue = this._getDefaultValue(key as string);\n\n    this.form.controls[key].setValue(defaultValue);\n\n    if (options?.skipResets) {\n      this._skipNextResets = true;\n    }\n  }\n\n  resetFieldsToDefault(keys: (keyof QueryFormValue<T>)[], options?: QueryFormWriteOptions) {\n    const defaults = keys.reduce(\n      (acc, key) => {\n        acc[key] = this._getDefaultValue(key as string);\n\n        return acc;\n      },\n      {} as Partial<QueryFormValue<T>>,\n    );\n\n    this.patchValue(defaults);\n\n    if (options?.skipResets) {\n      this._skipNextResets = true;\n    }\n  }\n\n  resetAllFieldsToDefault(options?: QueryFormWriteOptions & { skipFields?: (keyof QueryFormValue<T>)[] }) {\n    const keys = Object.keys(this._fields) as (keyof QueryFormValue<T>)[];\n\n    if (options?.skipFields) {\n      for (const key of options.skipFields) {\n        const index = keys.indexOf(key);\n\n        if (index !== -1) {\n          keys.splice(index, 1);\n        }\n      }\n    }\n\n    this.resetFieldsToDefault(keys, options);\n  }\n\n  private _getDefaultValue(key: string) {\n    const val = this._defaultValues[key];\n\n    if (typeof val === 'string' && val.startsWith(ET_ARR_PREFIX)) {\n      return JSON.parse(val.slice(ET_ARR_PREFIX.length));\n    }\n\n    return val ?? null;\n  }\n\n  private _transformKeyToQueryParam(key: string) {\n    if (!this._options?.queryParamPrefix) return key;\n\n    const prefix =\n      typeof this._options?.queryParamPrefix === 'string'\n        ? this._options.queryParamPrefix\n        : this._options.queryParamPrefix();\n\n    return `${prefix}-${key}`;\n  }\n\n  private _isDefaultValue(key: string, value: unknown) {\n    const normalizedValue = Array.isArray(value) ? `${ET_ARR_PREFIX}${JSON.stringify(value)}` : value;\n\n    return this._getDefaultValue(key) === normalizedValue;\n  }\n\n  private _setupFormGroup() {\n    const group = new FormGroup({} as QueryFormGroupControls<T>) as unknown as QueryFormGroup;\n\n    for (const [key, field] of Object.entries(this._fields)) {\n      group.addControl(key, field.control);\n    }\n\n    group._patchValue = group.patchValue;\n    group._setValue = group.setValue;\n\n    group.patchValue = this.patchValue.bind(this);\n    group.setValue = this.setValue.bind(this);\n\n    return group as unknown as FormGroup<QueryFormGroupControls<T>>;\n  }\n\n  private _extractDefaultValues() {\n    const defaultValues: Record<string, unknown> = {};\n\n    for (const [key, field] of Object.entries(this._fields)) {\n      const value = field.data.defaultValue !== undefined ? field.data.defaultValue : field.control.value;\n\n      if (Array.isArray(value)) {\n        defaultValues[key] = `${ET_ARR_PREFIX}${JSON.stringify(value)}`;\n      } else {\n        defaultValues[key] = value;\n      }\n    }\n\n    return defaultValues;\n  }\n\n  private _syncViaUrlQueryParams(values: QueryFormValue<T>, replaceUrl?: boolean) {\n    const queryParams = { ...clone(this._activatedRoute.snapshot.queryParams) };\n\n    for (const [key, value] of Object.entries(values)) {\n      const queryParamKey = this._transformKeyToQueryParam(key);\n      const field = this._fields[key];\n\n      if (!field) {\n        continue;\n      }\n\n      const isDefault = this._isDefaultValue(key, value);\n      const writeDefaultToUrl = field.data.appendDefaultValueToUrl === true;\n      const writeToUrl = field.data.appendToUrl !== false;\n\n      if (!writeToUrl || (isDefault && !writeDefaultToUrl)) {\n        queryParams[queryParamKey] = undefined;\n      } else {\n        queryParams[queryParamKey] = field.data.valueToQueryParamTransformFn\n          ? field.data.valueToQueryParamTransformFn?.(value)\n          : value;\n      }\n    }\n\n    this._zone.run(() => {\n      this._router.navigate([], {\n        queryParams,\n        replaceUrl,\n        queryParamsHandling: 'merge',\n      });\n    });\n  }\n\n  private _handleFormChange(forceOverwrite = false) {\n    const currentVal = clone(this._currentFormValue$.value);\n    const newVal = clone(this._formValue);\n\n    if (equal(currentVal, newVal)) {\n      return;\n    }\n\n    if (forceOverwrite) {\n      this._lastFormValue$.next(newVal);\n    } else {\n      this._lastFormValue$.next(currentVal);\n    }\n\n    this._currentFormValue$.next(newVal);\n  }\n}\n"]}

package/esm2022/lib/query-form/query-form.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/query-form/query-form.utils.mjs

@@ -0,0 +1,97 @@
+export const transformToString = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    return null;
+};
+export const transformToStringArray = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(transformToString).filter(Boolean);
+    }
+    else if (typeof value === 'string') {
+        return [transformToString(value)];
+    }
+    return null;
+};
+export const transformToNumber = (value) => {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return Number(value);
+    }
+    return null;
+};
+export const transformToNumberArray = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(transformToNumber).filter((item) => item !== null);
+    }
+    else if (typeof value === 'number') {
+        return [value];
+    }
+    return null;
+};
+export const transformToBoolean = (value) => {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value === 'true' || value === '1';
+    }
+    return null;
+};
+export const transformToBooleanArray = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(transformToBoolean).filter((item) => item !== null);
+    }
+    else if (typeof value === 'string' || typeof value === 'boolean') {
+        return [transformToBoolean(value)];
+    }
+    return null;
+};
+export const transformToDate = (value) => {
+    if (value instanceof Date) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const date = new Date(value);
+        if (isNaN(date.getTime())) {
+            return null;
+        }
+        return date;
+    }
+    return null;
+};
+export const transformToDateArray = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(transformToDate).filter((item) => item !== null);
+    }
+    else if (typeof value === 'string' || value instanceof Date) {
+        return [transformToDate(value)];
+    }
+    return null;
+};
+export const transformToSort = (value) => {
+    if (typeof value === 'string') {
+        const [active, direction] = value.split(':');
+        if (!active) {
+            return null;
+        }
+        return {
+            active,
+            direction: direction,
+        };
+    }
+    return null;
+};
+export const transformToSortQueryParam = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value && typeof value === 'object' && 'active' in value && 'direction' in value) {
+        const valAsSort = value;
+        return valAsSort.direction ? `${valAsSort.active}:${valAsSort.direction}` : null;
+    }
+    return null;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-form.utils.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/query-form/query-form.utils.ts"],"names":[],"mappings":"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","sourcesContent":["export const transformToString = (value: unknown) => {\n  if (typeof value === 'string') {\n    return value;\n  }\n\n  return null;\n};\n\nexport const transformToStringArray = (value: unknown) => {\n  if (Array.isArray(value)) {\n    return value.map(transformToString).filter(Boolean) as string[];\n  } else if (typeof value === 'string') {\n    return [transformToString(value)] as string[];\n  }\n\n  return null;\n};\n\nexport const transformToNumber = (value: unknown) => {\n  if (typeof value === 'number') {\n    return value;\n  }\n  if (typeof value === 'string') {\n    return Number(value);\n  }\n  return null;\n};\n\nexport const transformToNumberArray = (value: unknown) => {\n  if (Array.isArray(value)) {\n    return value.map(transformToNumber).filter((item) => item !== null) as number[];\n  } else if (typeof value === 'number') {\n    return [value] as number[];\n  }\n\n  return null;\n};\n\nexport const transformToBoolean = (value: unknown) => {\n  if (typeof value === 'boolean') {\n    return value;\n  }\n  if (typeof value === 'string') {\n    return value === 'true' || value === '1';\n  }\n  return null;\n};\n\nexport const transformToBooleanArray = (value: unknown) => {\n  if (Array.isArray(value)) {\n    return value.map(transformToBoolean).filter((item) => item !== null) as boolean[];\n  } else if (typeof value === 'string' || typeof value === 'boolean') {\n    return [transformToBoolean(value)] as boolean[];\n  }\n\n  return null;\n};\n\nexport const transformToDate = (value: unknown) => {\n  if (value instanceof Date) {\n    return value;\n  }\n  if (typeof value === 'string') {\n    const date = new Date(value);\n\n    if (isNaN(date.getTime())) {\n      return null;\n    }\n\n    return date;\n  }\n  return null;\n};\n\nexport const transformToDateArray = (value: unknown) => {\n  if (Array.isArray(value)) {\n    return value.map(transformToDate).filter((item) => item !== null) as Date[];\n  } else if (typeof value === 'string' || value instanceof Date) {\n    return [transformToDate(value)] as Date[];\n  }\n\n  return null;\n};\n\nexport const transformToSort = (value: unknown) => {\n  if (typeof value === 'string') {\n    const [active, direction] = value.split(':');\n\n    if (!active) {\n      return null;\n    }\n\n    return {\n      active,\n      direction: direction as 'asc' | 'desc',\n    };\n  }\n\n  return null;\n};\n\nexport const transformToSortQueryParam = (value: unknown) => {\n  if (typeof value === 'string') {\n    return value;\n  }\n  if (value && typeof value === 'object' && 'active' in value && 'direction' in value) {\n    const valAsSort = value as {\n      active: string;\n      direction: 'asc' | 'desc';\n    };\n\n    return valAsSort.direction ? `${valAsSort.active}:${valAsSort.direction}` : null;\n  }\n\n  return null;\n};\n"]}

package/esm2022/lib/query-store/index.mjs

@@ -0,0 +1,2 @@
+export * from './query-store';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3F1ZXJ5L3NyYy9saWIvcXVlcnktc3RvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3F1ZXJ5LXN0b3JlJztcbiJdfQ==