@ethlete/query 4.2.0 → 4.2.2

package/esm2022/lib/directives/infinity-query-trigger.directive.mjs

@@ -0,0 +1,55 @@
+import { Directive, ElementRef, inject, Input } from '@angular/core';
+import { fromEvent, Subject, takeUntil } from 'rxjs';
+import { INFINITY_QUERY_TOKEN } from './infinity-query.directive';
+import * as i0 from "@angular/core";
+class InfinityQueryTriggerDirective {
+    constructor() {
+        this._elementRef = inject((ElementRef));
+        this._infinityQuery = inject(INFINITY_QUERY_TOKEN);
+        this._destroy = new Subject();
+        this._observer = null;
+        this.click$ = fromEvent(this._elementRef.nativeElement, 'click');
+        this.scrollContainerSelector = null;
+    }
+    ngOnInit() {
+        const isInteractive = this._elementRef.nativeElement.hasAttribute('etInfinityQueryTrigger');
+        if (isInteractive) {
+            this.click$.pipe(takeUntil(this._destroy)).subscribe(() => this._infinityQuery.loadNextPage());
+        }
+        else {
+            this._setupIntersectionObserver();
+        }
+    }
+    ngOnDestroy() {
+        this._destroy.next(true);
+        this._destroy.unsubscribe();
+        this._observer?.disconnect();
+    }
+    _setupIntersectionObserver() {
+        this._observer = new IntersectionObserver((entries) => {
+            const entry = entries[0];
+            if (entry.isIntersecting && !this._infinityQuery.context.loading) {
+                this._infinityQuery.loadNextPage();
+            }
+        }, {
+            root: this.scrollContainerSelector ? document.querySelector(this.scrollContainerSelector) : null,
+            rootMargin: '0px',
+            threshold: [0.25, 0.5, 0.75, 1],
+        });
+        this._observer.observe(this._elementRef.nativeElement);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: InfinityQueryTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: InfinityQueryTriggerDirective, isStandalone: true, selector: "[etInfinityQueryTrigger], et-infinity-query-trigger", inputs: { scrollContainerSelector: "scrollContainerSelector" }, ngImport: i0 }); }
+}
+export { InfinityQueryTriggerDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: InfinityQueryTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[etInfinityQueryTrigger], et-infinity-query-trigger',
+                    standalone: true,
+                }]
+        }], propDecorators: { scrollContainerSelector: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/infinity-query.directive.mjs

@@ -0,0 +1,176 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ChangeDetectorRef, Directive, ErrorHandler, inject, InjectionToken, Input, TemplateRef, ViewContainerRef, } from '@angular/core';
+import { createDestroy, DelayableDirective } from '@ethlete/core';
+import { BehaviorSubject, combineLatest, skip, Subject, takeUntil, tap, withLatestFrom } from 'rxjs';
+import { InfinityQuery } from '../infinite-query';
+import { isQueryStateFailure, isQueryStateLoading, isQueryStateSuccess, switchQueryState, } from '../query';
+import * as i0 from "@angular/core";
+import * as i1 from "@ethlete/core";
+export const INFINITY_QUERY_TOKEN = new InjectionToken('INFINITY_QUERY_TOKEN');
+class InfinityQueryDirective {
+    constructor() {
+        this._queryConfigChanged$ = new Subject();
+        this._viewContext = {
+            $implicit: null,
+            etInfinityQuery: null,
+            loading: false,
+            error: null,
+            isFirstLoad: false,
+            canLoadMore: false,
+            currentPage: null,
+            currentCalculatedPage: null,
+            totalPages: null,
+            itemsPerPage: null,
+            currentQuery: null,
+        };
+        this._infinityQueryInstance = null;
+        this._destroy$ = createDestroy();
+        this._cdr = inject(ChangeDetectorRef);
+        this._viewContainerRef = inject(ViewContainerRef);
+        this._mainTemplateRef = inject((TemplateRef));
+        this._errorHandler = inject(ErrorHandler);
+        this._delayable = inject(DelayableDirective, { host: true });
+        this._data$ = new BehaviorSubject([]);
+        this._didReceiveFirstData$ = new BehaviorSubject(false);
+        this._isMainViewCreated = false;
+    }
+    get infinityQuery() {
+        return this._infinityQuery;
+    }
+    set infinityQuery(v) {
+        this._cleanup();
+        this._infinityQuery = v;
+        this._infinityQueryInstance = this._setupInfinityQuery(v);
+        this.loadNextPage();
+    }
+    get context() {
+        return this._viewContext;
+    }
+    get instance() {
+        return this._infinityQueryInstance;
+    }
+    get data$() {
+        return this._data$.asObservable();
+    }
+    get data() {
+        return this._data$.getValue();
+    }
+    static ngTemplateContextGuard(dir, ctx) {
+        return true;
+    }
+    ngOnInit() {
+        this._renderMainView();
+    }
+    _setupInfinityQuery(config) {
+        const instance = new InfinityQuery(config);
+        combineLatest([
+            instance.currentQuery$.pipe(switchQueryState(), withLatestFrom(instance.currentQuery$)),
+            this._delayable.isDelayed$,
+            this._didReceiveFirstData$,
+        ])
+            .pipe(tap(([[state, currentQuery], isDelayed, didReceiveFirstData]) => {
+            this._viewContext.currentPage = instance.currentPage;
+            this._viewContext.totalPages = instance.totalPages;
+            this._viewContext.itemsPerPage = instance.itemsPerPage;
+            this._viewContext.canLoadMore =
+                (instance.totalPages && instance.currentPage && instance.totalPages > instance.currentPage) || false;
+            this._viewContext.currentCalculatedPage = instance.currentCalculatedPage;
+            this._viewContext.currentQuery = currentQuery;
+            if (isQueryStateLoading(state) || isDelayed || (!didReceiveFirstData && isQueryStateSuccess(state))) {
+                this._viewContext.loading = true;
+                this._viewContext.error = null;
+                this._viewContext.isFirstLoad = this.context.etInfinityQuery === null;
+            }
+            else if (isQueryStateFailure(state)) {
+                this._viewContext.loading = false;
+                this._viewContext.error = state.error;
+                this._viewContext.isFirstLoad = false;
+                this._errorHandler.handleError(state.error);
+            }
+            else if (isQueryStateSuccess(state)) {
+                this._viewContext.loading = false;
+                this._viewContext.error = null;
+                this._viewContext.isFirstLoad = false;
+            }
+            else {
+                this._viewContext.loading = false;
+                this._viewContext.error = null;
+                this._viewContext.etInfinityQuery = null;
+                this._viewContext.$implicit = null;
+                this._viewContext.isFirstLoad = false;
+                this._viewContext.canLoadMore = false;
+                this._viewContext.currentPage = null;
+                this._viewContext.itemsPerPage = null;
+                this._viewContext.totalPages = null;
+                this._viewContext.currentQuery = null;
+                this._data$.next([]);
+            }
+            this._cdr.markForCheck();
+        }), takeUntil(this._destroy$), takeUntil(this._queryConfigChanged$))
+            .subscribe();
+        instance.data$
+            .pipe(skip(1), tap((data) => {
+            this._viewContext.etInfinityQuery = this._viewContext.$implicit = data;
+            this._data$.next(data);
+            if (!this._didReceiveFirstData$.getValue()) {
+                this._didReceiveFirstData$.next(true);
+            }
+            this._cdr.markForCheck();
+        }), takeUntil(this._destroy$), takeUntil(this._queryConfigChanged$))
+            .subscribe();
+        return instance;
+    }
+    loadNextPage() {
+        if (!this._infinityQueryInstance) {
+            return;
+        }
+        if (this._viewContext.loading) {
+            return;
+        }
+        this._infinityQueryInstance.nextPage();
+    }
+    reset(newConfig) {
+        if (!this._infinityQueryInstance) {
+            return;
+        }
+        this._infinityQueryInstance.reset(newConfig);
+    }
+    _renderMainView() {
+        if (!this._isMainViewCreated) {
+            this._isMainViewCreated = true;
+            this._viewContainerRef.createEmbeddedView(this._mainTemplateRef, this._viewContext);
+        }
+    }
+    _cleanup() {
+        this._queryConfigChanged$.next(true);
+        this._viewContext.loading = false;
+        this._viewContext.error = null;
+        this._viewContext.etInfinityQuery = null;
+        this._viewContext.$implicit = null;
+        this._viewContext.isFirstLoad = false;
+        this._viewContext.canLoadMore = false;
+        this._viewContext.currentPage = null;
+        this._viewContext.itemsPerPage = null;
+        this._viewContext.totalPages = null;
+        this._viewContext.currentQuery = null;
+        this._data$.next([]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: InfinityQueryDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: InfinityQueryDirective, isStandalone: true, selector: "[etInfinityQuery]", inputs: { infinityQuery: ["etInfinityQuery", "infinityQuery"] }, providers: [{ provide: INFINITY_QUERY_TOKEN, useExisting: InfinityQueryDirective }], exportAs: ["etInfinityQuery"], hostDirectives: [{ directive: i1.DelayableDirective }], ngImport: i0 }); }
+}
+export { InfinityQueryDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: InfinityQueryDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[etInfinityQuery]',
+                    exportAs: 'etInfinityQuery',
+                    standalone: true,
+                    providers: [{ provide: INFINITY_QUERY_TOKEN, useExisting: InfinityQueryDirective }],
+                    hostDirectives: [DelayableDirective],
+                }]
+        }], propDecorators: { infinityQuery: [{
+                type: Input,
+                args: ['etInfinityQuery']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infinity-query.directive.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/directives/infinity-query.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport {\n  ChangeDetectorRef,\n  Directive,\n  ErrorHandler,\n  inject,\n  InjectionToken,\n  Input,\n  OnInit,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport { createDestroy, DelayableDirective } from '@ethlete/core';\nimport { BehaviorSubject, combineLatest, skip, Subject, takeUntil, tap, withLatestFrom } from 'rxjs';\nimport { InfinityQuery, InfinityQueryConfig, InfinityQueryOf } from '../infinite-query';\nimport {\n  BaseArguments,\n  isQueryStateFailure,\n  isQueryStateLoading,\n  isQueryStateSuccess,\n  switchQueryState,\n} from '../query';\nimport { AnyQueryCreator, ConstructQuery } from '../query-creator';\nimport { RequestError } from '../request';\n\ninterface InfinityQueryContext<\n  Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>,\n> {\n  $implicit: Q['response']['arrayType'] | null;\n  etInfinityQuery: Q['response']['arrayType'] | null;\n  loading: boolean;\n  error: RequestError<unknown> | null;\n\n  isFirstLoad: boolean;\n  canLoadMore: boolean;\n  currentPage: number | null;\n  currentCalculatedPage: number | null;\n  totalPages: number | null;\n  itemsPerPage: number | null;\n\n  currentQuery: ConstructQuery<Q['queryCreator']> | null;\n}\n\nexport const INFINITY_QUERY_TOKEN = new InjectionToken<InfinityQueryDirective<any>>('INFINITY_QUERY_TOKEN');\n\n@Directive({\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: '[etInfinityQuery]',\n  exportAs: 'etInfinityQuery',\n  standalone: true,\n  providers: [{ provide: INFINITY_QUERY_TOKEN, useExisting: InfinityQueryDirective }],\n  hostDirectives: [DelayableDirective],\n})\nexport class InfinityQueryDirective<\n  Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>,\n> implements OnInit\n{\n  private readonly _queryConfigChanged$ = new Subject<boolean>();\n  private readonly _viewContext: InfinityQueryContext<Q> = {\n    $implicit: null,\n    etInfinityQuery: null,\n    loading: false,\n    error: null,\n\n    isFirstLoad: false,\n    canLoadMore: false,\n    currentPage: null,\n    currentCalculatedPage: null,\n    totalPages: null,\n    itemsPerPage: null,\n\n    currentQuery: null,\n  };\n  private _infinityQueryInstance: InfinityQueryOf<Q> | null = null;\n\n  private readonly _destroy$ = createDestroy();\n  private readonly _cdr = inject(ChangeDetectorRef);\n  private readonly _viewContainerRef = inject(ViewContainerRef);\n  private readonly _mainTemplateRef = inject(TemplateRef<InfinityQueryContext<Q>>);\n  private readonly _errorHandler = inject(ErrorHandler);\n  private readonly _delayable = inject(DelayableDirective, { host: true });\n\n  private readonly _data$ = new BehaviorSubject<Q['response']['arrayType']>([]);\n\n  private _didReceiveFirstData$ = new BehaviorSubject(false);\n  private _isMainViewCreated = false;\n\n  @Input('etInfinityQuery')\n  get infinityQuery(): Q {\n    return this._infinityQuery;\n  }\n  set infinityQuery(v: Q) {\n    this._cleanup();\n\n    this._infinityQuery = v;\n    this._infinityQueryInstance = this._setupInfinityQuery(v);\n    this.loadNextPage();\n  }\n  private _infinityQuery!: Q;\n\n  get context() {\n    return this._viewContext;\n  }\n\n  get instance() {\n    return this._infinityQueryInstance;\n  }\n\n  get data$() {\n    return this._data$.asObservable();\n  }\n\n  get data() {\n    return this._data$.getValue();\n  }\n\n  static ngTemplateContextGuard<\n    Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>,\n  >(dir: InfinityQueryDirective<Q>, ctx: unknown): ctx is InfinityQueryContext<Q> {\n    return true;\n  }\n\n  ngOnInit(): void {\n    this._renderMainView();\n  }\n\n  private _setupInfinityQuery(config: Q) {\n    const instance = new InfinityQuery(config) as InfinityQueryOf<Q>;\n\n    combineLatest([\n      instance.currentQuery$.pipe(switchQueryState(), withLatestFrom(instance.currentQuery$)),\n      this._delayable.isDelayed$,\n      this._didReceiveFirstData$,\n    ])\n      .pipe(\n        tap(([[state, currentQuery], isDelayed, didReceiveFirstData]) => {\n          this._viewContext.currentPage = instance.currentPage;\n          this._viewContext.totalPages = instance.totalPages;\n          this._viewContext.itemsPerPage = instance.itemsPerPage;\n          this._viewContext.canLoadMore =\n            (instance.totalPages && instance.currentPage && instance.totalPages > instance.currentPage) || false;\n          this._viewContext.currentCalculatedPage = instance.currentCalculatedPage;\n\n          this._viewContext.currentQuery = currentQuery;\n\n          if (isQueryStateLoading(state) || isDelayed || (!didReceiveFirstData && isQueryStateSuccess(state))) {\n            this._viewContext.loading = true;\n            this._viewContext.error = null;\n            this._viewContext.isFirstLoad = this.context.etInfinityQuery === null;\n          } else if (isQueryStateFailure(state)) {\n            this._viewContext.loading = false;\n            this._viewContext.error = state.error;\n            this._viewContext.isFirstLoad = false;\n            this._errorHandler.handleError(state.error);\n          } else if (isQueryStateSuccess(state)) {\n            this._viewContext.loading = false;\n            this._viewContext.error = null;\n            this._viewContext.isFirstLoad = false;\n          } else {\n            this._viewContext.loading = false;\n            this._viewContext.error = null;\n            this._viewContext.etInfinityQuery = null;\n            this._viewContext.$implicit = null;\n\n            this._viewContext.isFirstLoad = false;\n            this._viewContext.canLoadMore = false;\n            this._viewContext.currentPage = null;\n            this._viewContext.itemsPerPage = null;\n            this._viewContext.totalPages = null;\n\n            this._viewContext.currentQuery = null;\n\n            this._data$.next([]);\n          }\n\n          this._cdr.markForCheck();\n        }),\n        takeUntil(this._destroy$),\n        takeUntil(this._queryConfigChanged$),\n      )\n      .subscribe();\n\n    instance.data$\n      .pipe(\n        skip(1),\n        tap((data) => {\n          this._viewContext.etInfinityQuery = this._viewContext.$implicit = data as Q['response']['arrayType'] | null;\n          this._data$.next(data);\n\n          if (!this._didReceiveFirstData$.getValue()) {\n            this._didReceiveFirstData$.next(true);\n          }\n\n          this._cdr.markForCheck();\n        }),\n        takeUntil(this._destroy$),\n        takeUntil(this._queryConfigChanged$),\n      )\n      .subscribe();\n\n    return instance;\n  }\n\n  loadNextPage() {\n    if (!this._infinityQueryInstance) {\n      return;\n    }\n\n    if (this._viewContext.loading) {\n      return;\n    }\n\n    this._infinityQueryInstance.nextPage();\n  }\n\n  reset(newConfig?: Omit<Q, 'queryCreator' | 'response'>) {\n    if (!this._infinityQueryInstance) {\n      return;\n    }\n\n    this._infinityQueryInstance.reset(newConfig as any);\n  }\n\n  private _renderMainView(): void {\n    if (!this._isMainViewCreated) {\n      this._isMainViewCreated = true;\n      this._viewContainerRef.createEmbeddedView(this._mainTemplateRef, this._viewContext);\n    }\n  }\n\n  private _cleanup() {\n    this._queryConfigChanged$.next(true);\n\n    this._viewContext.loading = false;\n    this._viewContext.error = null;\n    this._viewContext.etInfinityQuery = null;\n    this._viewContext.$implicit = null;\n\n    this._viewContext.isFirstLoad = false;\n    this._viewContext.canLoadMore = false;\n    this._viewContext.currentPage = null;\n    this._viewContext.itemsPerPage = null;\n    this._viewContext.totalPages = null;\n\n    this._viewContext.currentQuery = null;\n\n    this._data$.next([]);\n  }\n}\n"]}

package/esm2022/lib/directives/query.directive.mjs

@@ -0,0 +1,113 @@
+import { ChangeDetectorRef, Directive, ErrorHandler, Input, TemplateRef, ViewContainerRef, } from '@angular/core';
+import { tap } from 'rxjs';
+import { isQuery, isQueryStateFailure, isQueryStateLoading, isQueryStateSuccess, } from '../query';
+import * as i0 from "@angular/core";
+class QueryDirective {
+    get query() {
+        return this._query;
+    }
+    set query(v) {
+        this._query = v;
+        this._subscribeToQuery();
+    }
+    get cache() {
+        return this._cache;
+    }
+    set cache(v) {
+        this._cache = v;
+    }
+    constructor(_mainTemplateRef, _viewContainerRef, _errorHandler, _cdr) {
+        this._mainTemplateRef = _mainTemplateRef;
+        this._viewContainerRef = _viewContainerRef;
+        this._errorHandler = _errorHandler;
+        this._cdr = _cdr;
+        this._isMainViewCreated = false;
+        this._subscription = null;
+        this._viewContext = {
+            $implicit: null,
+            etQuery: null,
+            loading: false,
+            refreshing: false,
+            error: null,
+            progress: null,
+        };
+        this._cache = false;
+    }
+    static ngTemplateContextGuard(dir, ctx) {
+        return true;
+    }
+    ngOnInit() {
+        this._renderMainView();
+    }
+    ngOnDestroy() {
+        this._subscription?.unsubscribe();
+    }
+    _subscribeToQuery() {
+        this._subscription?.unsubscribe();
+        this._subscription = null;
+        if (!this.query) {
+            this._viewContext.$implicit = null;
+            this._viewContext.etQuery = null;
+            this._viewContext.loading = false;
+            this._viewContext.refreshing = false;
+            this._viewContext.error = null;
+            this._viewContext.progress = null;
+            return;
+        }
+        const query = isQuery(this.query) ? this.query : this.query.query;
+        const sub = query.state$.pipe(tap((state) => this._updateView(state))).subscribe();
+        this._subscription = sub;
+    }
+    _updateView(state) {
+        if (isQueryStateLoading(state)) {
+            this._viewContext.loading = true;
+            this._viewContext.progress = state.progress ?? null;
+            this._viewContext.refreshing = state.meta.triggeredVia === 'auto' || state.meta.triggeredVia === 'poll';
+        }
+        else {
+            this._viewContext.loading = false;
+            this._viewContext.refreshing = false;
+            this._viewContext.progress = null;
+        }
+        if (isQueryStateSuccess(state)) {
+            this._viewContext.etQuery = state.response;
+            this._viewContext.$implicit = state.response;
+        }
+        else if (!this.cache) {
+            this._viewContext.etQuery = null;
+            this._viewContext.$implicit = null;
+        }
+        if (isQueryStateFailure(state)) {
+            this._viewContext.error = state.error;
+            this._errorHandler.handleError(state.error);
+        }
+        else {
+            this._viewContext.error = null;
+        }
+        this._cdr.markForCheck();
+    }
+    _renderMainView() {
+        if (!this._isMainViewCreated) {
+            this._isMainViewCreated = true;
+            this._viewContainerRef.createEmbeddedView(this._mainTemplateRef, this._viewContext);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: QueryDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: i0.ErrorHandler }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: QueryDirective, isStandalone: true, selector: "[etQuery]", inputs: { query: ["etQuery", "query"], cache: ["etQueryCache", "cache"] }, ngImport: i0 }); }
+}
+export { QueryDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: QueryDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[etQuery]',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: i0.ErrorHandler }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { query: [{
+                type: Input,
+                args: ['etQuery']
+            }], cache: [{
+                type: Input,
+                args: ['etQueryCache']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.directive.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/directives/query.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Directive,\n  ErrorHandler,\n  Input,\n  OnDestroy,\n  OnInit,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport { Subscription, tap } from 'rxjs';\nimport {\n  AnyQuery,\n  AnyQueryCollection,\n  QueryOf,\n  QueryState,\n  isQuery,\n  isQueryStateFailure,\n  isQueryStateLoading,\n  isQueryStateSuccess,\n} from '../query';\nimport { QueryDataOf } from '../query-creator';\nimport { RequestError, RequestProgress } from '../request';\n\ninterface QueryContext<Q extends AnyQuery | null> {\n  $implicit: QueryDataOf<Q> | null;\n  etQuery: QueryDataOf<Q> | null;\n  loading: boolean;\n  refreshing: boolean;\n  progress: RequestProgress | null;\n  error: RequestError<unknown> | null;\n}\n\n@Directive({\n  // eslint-disable-next-line @angular-eslint/directive-selector\n  selector: '[etQuery]',\n  standalone: true,\n})\nexport class QueryDirective<Q extends AnyQuery | AnyQueryCollection | null> implements OnInit, OnDestroy {\n  private _isMainViewCreated = false;\n  private _subscription: Subscription | null = null;\n\n  private readonly _viewContext: QueryContext<QueryOf<Q>> = {\n    $implicit: null,\n    etQuery: null,\n    loading: false,\n    refreshing: false,\n    error: null,\n    progress: null,\n  };\n\n  @Input('etQuery')\n  get query(): Q {\n    return this._query;\n  }\n  set query(v: Q) {\n    this._query = v;\n\n    this._subscribeToQuery();\n  }\n  private _query!: Q;\n\n  @Input('etQueryCache')\n  get cache(): boolean {\n    return this._cache;\n  }\n  set cache(v: boolean) {\n    this._cache = v;\n  }\n  private _cache = false;\n\n  constructor(\n    private _mainTemplateRef: TemplateRef<QueryContext<QueryOf<Q>>>,\n    private _viewContainerRef: ViewContainerRef,\n    private _errorHandler: ErrorHandler,\n    private _cdr: ChangeDetectorRef,\n  ) {}\n\n  static ngTemplateContextGuard<Q extends AnyQuery | AnyQueryCollection | null>(\n    dir: QueryDirective<Q>,\n    ctx: unknown,\n  ): ctx is QueryContext<QueryOf<Q>> {\n    return true;\n  }\n\n  ngOnInit(): void {\n    this._renderMainView();\n  }\n\n  ngOnDestroy(): void {\n    this._subscription?.unsubscribe();\n  }\n\n  private _subscribeToQuery(): void {\n    this._subscription?.unsubscribe();\n    this._subscription = null;\n\n    if (!this.query) {\n      this._viewContext.$implicit = null;\n      this._viewContext.etQuery = null;\n      this._viewContext.loading = false;\n      this._viewContext.refreshing = false;\n      this._viewContext.error = null;\n      this._viewContext.progress = null;\n      return;\n    }\n\n    const query = isQuery(this.query) ? this.query : this.query.query;\n\n    const sub = query.state$.pipe(tap((state) => this._updateView(state))).subscribe();\n\n    this._subscription = sub;\n  }\n\n  private _updateView(state: QueryState) {\n    if (isQueryStateLoading(state)) {\n      this._viewContext.loading = true;\n      this._viewContext.progress = state.progress ?? null;\n      this._viewContext.refreshing = state.meta.triggeredVia === 'auto' || state.meta.triggeredVia === 'poll';\n    } else {\n      this._viewContext.loading = false;\n      this._viewContext.refreshing = false;\n      this._viewContext.progress = null;\n    }\n\n    if (isQueryStateSuccess(state)) {\n      this._viewContext.etQuery = state.response as QueryDataOf<QueryOf<Q>>;\n      this._viewContext.$implicit = state.response as QueryDataOf<QueryOf<Q>>;\n    } else if (!this.cache) {\n      this._viewContext.etQuery = null;\n      this._viewContext.$implicit = null;\n    }\n\n    if (isQueryStateFailure(state)) {\n      this._viewContext.error = state.error;\n\n      this._errorHandler.handleError(state.error);\n    } else {\n      this._viewContext.error = null;\n    }\n\n    this._cdr.markForCheck();\n  }\n\n  private _renderMainView(): void {\n    if (!this._isMainViewCreated) {\n      this._isMainViewCreated = true;\n      this._viewContainerRef.createEmbeddedView(this._mainTemplateRef, this._viewContext);\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,173 @@
+import { inject, isDevMode } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+import { clone, equal } from '@ethlete/core';
+import { BehaviorSubject, combineLatest, concat, debounceTime, distinctUntilChanged, map, pairwise, shareReplay, startWith, take, tap, } from 'rxjs';
+export class QueryField {
+    get control() {
+        return this.data.control;
+    }
+    constructor(data) {
+        this.data = data;
+        this.changes$ = this._setupChangesObservable();
+        this._currentDebounceTimeout = null;
+    }
+    setValue(value, options) {
+        if (this._currentDebounceTimeout !== null) {
+            clearTimeout(this._currentDebounceTimeout);
+        }
+        if (this.data.debounce && !options?.skipDebounce) {
+            this._currentDebounceTimeout = window.setTimeout(() => {
+                this.control.setValue(value);
+            }, this.data.debounce);
+        }
+        else {
+            this.control.setValue(value);
+        }
+    }
+    _setupChangesObservable() {
+        const obs = this.control.valueChanges.pipe(startWith(this.control.value));
+        if (!this.data.debounce) {
+            return obs;
+        }
+        // The initial value should get emitted immediately
+        // concat switches to the debounced observable after the first observable is completed
+        return concat(obs.pipe(take(1)), this.control.valueChanges.pipe(debounceTime(this.data.debounce)));
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class QueryForm {
+    get _formValue() {
+        return this.form.getRawValue();
+    }
+    get controls() {
+        return this.form.controls;
+    }
+    get value() {
+        return this._changes$.value.currentValue;
+    }
+    constructor(_fields) {
+        this._fields = _fields;
+        this._router = inject(Router, { optional: true });
+        this._activatedRoute = inject(ActivatedRoute, { optional: true });
+        this._defaultValues = this._extractDefaultValues();
+        this.form = this._setupFormGroup();
+        this._changes$ = new BehaviorSubject({
+            previousValue: null,
+            currentValue: this.form.getRawValue(),
+        });
+        this.changes$ = this._changes$.asObservable();
+    }
+    observe(options) {
+        return combineLatest(Object.values(this._fields).map((field) => field.changes$)).pipe(map(() => this._formValue), distinctUntilChanged((a, b) => equal(a, b)), tap((values) => {
+            if (options?.syncViaUrlQueryParams !== false) {
+                this._syncViaUrlQueryParams(values);
+            }
+        }), pairwise(), startWith([null, this._formValue]), map(([previousValue, currentValue]) => ({ previousValue, currentValue })), tap(({ previousValue, currentValue }) => {
+            let didResetValues = false;
+            for (const formFieldKey in this._fields) {
+                const resets = this._fields[formFieldKey].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._defaultValues[formFieldKey];
+                        const currentValueForKeyToReset = currentValue[formFieldKey];
+                        if (equal(defaultValueForKeyToReset, currentValueForKeyToReset)) {
+                            continue;
+                        }
+                        this.form.controls[formFieldKey].setValue(defaultValueForKeyToReset);
+                        didResetValues = true;
+                        break;
+                    }
+                }
+            }
+            if (!didResetValues) {
+                this._changes$.next({
+                    previousValue,
+                    currentValue,
+                });
+            }
+        }), shareReplay({ bufferSize: 1, refCount: true }), map(() => null));
+    }
+    setFormValueFromUrlQueryParams(options) {
+        if (!this._activatedRoute) {
+            throw new Error('Cannot set form value from url query params without ActivatedRoute');
+        }
+        const queryParams = this._activatedRoute.snapshot.queryParams;
+        for (const [key, field] of Object.entries(this._fields)) {
+            const value = queryParams[key];
+            // We only check using == because the value types can be different (e.g. "1" and 1)
+            if (value === undefined || value == field.control.value) {
+                continue;
+            }
+            const deserializedValue = field.data.queryParamToValueTransformFn?.(value) ?? value;
+            field.setValue(deserializedValue, { skipDebounce: options?.skipDebounce ?? true });
+        }
+    }
+    updateFormOnUrlQueryParamsChange() {
+        if (!this._activatedRoute) {
+            throw new Error('Cannot update form on url query params change without ActivatedRoute');
+        }
+        return this._activatedRoute.queryParams.pipe(tap(() => this.setFormValueFromUrlQueryParams()));
+    }
+    _getDefaultValue(key) {
+        return this._defaultValues[key] ?? null;
+    }
+    _isDefaultValue(key, value) {
+        const normalizedValue = Array.isArray(value) ? 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);
+        }
+        return group;
+    }
+    _extractDefaultValues() {
+        const defaultValues = {};
+        for (const [key, field] of Object.entries(this._fields)) {
+            const value = field.control.value;
+            if (value === null || value === undefined) {
+                continue;
+            }
+            if (Array.isArray(value)) {
+                defaultValues[key] = JSON.stringify(value);
+            }
+            else {
+                defaultValues[key] = value;
+            }
+        }
+        return defaultValues;
+    }
+    _syncViaUrlQueryParams(values) {
+        if (!this._router || !this._activatedRoute) {
+            return;
+        }
+        const queryParams = { ...clone(this._activatedRoute.snapshot.queryParams) };
+        for (const [key, value] of Object.entries(values)) {
+            if (this._isDefaultValue(key, value) || this._fields[key].data.appendToUrl === false) {
+                delete queryParams[key];
+            }
+            else {
+                queryParams[key] = this._fields[key].data.valueToQueryParamTransformFn
+                    ? this._fields[key].data.valueToQueryParamTransformFn?.(value)
+                    : value;
+            }
+        }
+        this._router.navigate([], {
+            queryParams,
+        });
+    }
+}
+//# 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 { inject, isDevMode } from '@angular/core';\nimport { FormGroup } from '@angular/forms';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { clone, equal } from '@ethlete/core';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  concat,\n  debounceTime,\n  distinctUntilChanged,\n  map,\n  pairwise,\n  shareReplay,\n  startWith,\n  take,\n  tap,\n} from 'rxjs';\nimport {\n  QueryFieldOptions,\n  QueryFormGroup,\n  QueryFormObserveOptions,\n  QueryFormValue,\n  QueryFormValueEvent,\n} from './query-form.types';\n\nexport class QueryField<T> {\n  changes$ = this._setupChangesObservable();\n\n  get control() {\n    return this.data.control;\n  }\n\n  private _currentDebounceTimeout: number | null = null;\n\n  constructor(public data: QueryFieldOptions<T>) {}\n\n  setValue(value: T | null, options?: { skipDebounce?: boolean }) {\n    if (this._currentDebounceTimeout !== null) {\n      clearTimeout(this._currentDebounceTimeout);\n    }\n\n    if (this.data.debounce && !options?.skipDebounce) {\n      this._currentDebounceTimeout = window.setTimeout(() => {\n        this.control.setValue(value);\n      }, this.data.debounce);\n    } else {\n      this.control.setValue(value);\n    }\n  }\n\n  private _setupChangesObservable() {\n    const obs = this.control.valueChanges.pipe(startWith(this.control.value));\n\n    if (!this.data.debounce) {\n      return obs;\n    }\n\n    // The initial value should get emitted immediately\n    // concat switches to the debounced observable after the first observable is completed\n    return concat(obs.pipe(take(1)), this.control.valueChanges.pipe(debounceTime(this.data.debounce)));\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class QueryForm<T extends Record<string, QueryField<any>>> {\n  private _router = inject(Router, { optional: true });\n  private _activatedRoute = inject(ActivatedRoute, { optional: true });\n  private _defaultValues = this._extractDefaultValues();\n\n  form = this._setupFormGroup();\n\n  private get _formValue() {\n    return this.form.getRawValue() as QueryFormValue<T>;\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\n  get controls() {\n    return this.form.controls;\n  }\n\n  get value() {\n    return this._changes$.value.currentValue;\n  }\n\n  constructor(private _fields: T) {}\n\n  observe(options?: QueryFormObserveOptions) {\n    return combineLatest(Object.values(this._fields).map((field) => field.changes$)).pipe(\n      map(() => this._formValue),\n      distinctUntilChanged((a, b) => equal(a, b)),\n      tap((values) => {\n        if (options?.syncViaUrlQueryParams !== false) {\n          this._syncViaUrlQueryParams(values);\n        }\n      }),\n      pairwise(),\n      startWith([null, this._formValue] as const),\n      map(([previousValue, currentValue]) => ({ previousValue, currentValue })),\n      tap(({ previousValue, currentValue }) => {\n        let didResetValues = false;\n\n        for (const formFieldKey in this._fields) {\n          const resets = this._fields[formFieldKey].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._defaultValues[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        if (!didResetValues) {\n          this._changes$.next({\n            previousValue,\n            currentValue,\n          });\n        }\n      }),\n      shareReplay({ bufferSize: 1, refCount: true }),\n      map(() => null),\n    );\n  }\n\n  setFormValueFromUrlQueryParams(options?: { skipDebounce?: boolean }) {\n    if (!this._activatedRoute) {\n      throw new Error('Cannot set form value from url query params without ActivatedRoute');\n    }\n\n    const queryParams = this._activatedRoute.snapshot.queryParams;\n\n    for (const [key, field] of Object.entries(this._fields)) {\n      const value = queryParams[key];\n\n      // We only check using == because the value types can be different (e.g. \"1\" and 1)\n      if (value === undefined || value == field.control.value) {\n        continue;\n      }\n\n      const deserializedValue = field.data.queryParamToValueTransformFn?.(value) ?? value;\n\n      field.setValue(deserializedValue, { skipDebounce: options?.skipDebounce ?? true });\n    }\n  }\n\n  updateFormOnUrlQueryParamsChange() {\n    if (!this._activatedRoute) {\n      throw new Error('Cannot update form on url query params change without ActivatedRoute');\n    }\n\n    return this._activatedRoute.queryParams.pipe(tap(() => this.setFormValueFromUrlQueryParams()));\n  }\n\n  private _getDefaultValue(key: string) {\n    return this._defaultValues[key] ?? null;\n  }\n\n  private _isDefaultValue(key: string, value: unknown) {\n    const normalizedValue = Array.isArray(value) ? JSON.stringify(value) : value;\n\n    return this._getDefaultValue(key) === normalizedValue;\n  }\n\n  private _setupFormGroup() {\n    const group = new FormGroup({} as QueryFormGroup<T>);\n\n    for (const [key, field] of Object.entries(this._fields)) {\n      group.addControl(key, field.control);\n    }\n\n    return group;\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.control.value;\n\n      if (value === null || value === undefined) {\n        continue;\n      }\n\n      if (Array.isArray(value)) {\n        defaultValues[key] = JSON.stringify(value);\n      } else {\n        defaultValues[key] = value;\n      }\n    }\n\n    return defaultValues;\n  }\n\n  private _syncViaUrlQueryParams(values: Record<string, unknown>) {\n    if (!this._router || !this._activatedRoute) {\n      return;\n    }\n\n    const queryParams = { ...clone(this._activatedRoute.snapshot.queryParams) };\n\n    for (const [key, value] of Object.entries(values)) {\n      if (this._isDefaultValue(key, value) || this._fields[key].data.appendToUrl === false) {\n        delete queryParams[key];\n      } else {\n        queryParams[key] = this._fields[key].data.valueToQueryParamTransformFn\n          ? this._fields[key].data.valueToQueryParamTransformFn?.(value)\n          : value;\n      }\n    }\n\n    this._router.navigate([], {\n      queryParams,\n    });\n  }\n}\n"]}

package/{esm2020 → esm2022}/lib/query-form/query-form.types.mjs

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