@ethlete/query 5.16.0 → 5.16.2

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

@@ -0,0 +1,56 @@
+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";
+export 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.tagName === 'BUTTON';
+        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)
+                return;
+            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: "18.1.1", ngImport: i0, type: InfinityQueryTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: InfinityQueryTriggerDirective, isStandalone: true, selector: "[etInfinityQueryTrigger], et-infinity-query-trigger", inputs: { scrollContainerSelector: "scrollContainerSelector" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", 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,147 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ChangeDetectorRef, Directive, ErrorHandler, inject, InjectionToken, Input, TemplateRef, ViewContainerRef, } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { createDestroy, DelayableDirective } from '@ethlete/core';
+import { BehaviorSubject, combineLatest, 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');
+export class InfinityQueryDirective {
+    get infinityQuery() {
+        return this._infinityQuery;
+    }
+    set infinityQuery(v) {
+        this._cleanup();
+        this._infinityQuery = v;
+        this._infinityQueryInstance = this._setupInfinityQuery(v);
+        this._infinityQueryInstance.nextPage();
+    }
+    get context() {
+        return this._viewContext;
+    }
+    get instance() {
+        return this._infinityQueryInstance;
+    }
+    get data$() {
+        return this._data$.asObservable();
+    }
+    static ngTemplateContextGuard(dir, ctx) {
+        return true;
+    }
+    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.data = toSignal(this._data$, { requireSync: true });
+        this._viewContainerRef.createEmbeddedView(this._mainTemplateRef, this._viewContext);
+    }
+    _setupInfinityQuery(config) {
+        const instance = new InfinityQuery(config, this._destroy$);
+        combineLatest([
+            instance.currentQuery$.pipe(switchQueryState(), withLatestFrom(instance.currentQuery$)),
+            this._delayable.isDelayed$,
+            instance.data$,
+        ])
+            .pipe(tap(([[state, currentQuery], isDelayed, infinityArray]) => {
+            this._viewContext.currentPage = instance.currentPage;
+            this._viewContext.totalPages = instance.totalPages;
+            this._viewContext.itemsPerPage = instance.itemsPerPage;
+            this._viewContext.canLoadMore =
+                (instance.totalPages !== null &&
+                    instance.currentPage !== null &&
+                    instance.totalPages > instance.currentPage) ||
+                    false;
+            this._viewContext.currentCalculatedPage = instance.currentCalculatedPage;
+            this._viewContext.currentQuery = currentQuery;
+            if (isQueryStateLoading(state) || isDelayed || !infinityArray) {
+                this._viewContext.loading = state ? state.meta.triggeredVia !== 'poll' : 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;
+                this._viewContext.etInfinityQuery = this._viewContext.$implicit =
+                    infinityArray;
+                this._data$.next(infinityArray);
+            }
+            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);
+    }
+    _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: "18.1.1", ngImport: i0, type: InfinityQueryDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", 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 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", 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],
+                }]
+        }], ctorParameters: () => [], 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  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport { toSignal } from '@angular/core/rxjs-interop';\nimport { createDestroy, DelayableDirective } from '@ethlete/core';\nimport { BehaviorSubject, combineLatest, 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> {\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  @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._infinityQueryInstance.nextPage();\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  data = toSignal(this._data$, { requireSync: true });\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  constructor() {\n    this._viewContainerRef.createEmbeddedView(this._mainTemplateRef, this._viewContext);\n  }\n\n  private _setupInfinityQuery(config: Q) {\n    const instance = new InfinityQuery(config, this._destroy$) as InfinityQueryOf<Q>;\n\n    combineLatest([\n      instance.currentQuery$.pipe(switchQueryState(), withLatestFrom(instance.currentQuery$)),\n      this._delayable.isDelayed$,\n      instance.data$,\n    ])\n      .pipe(\n        tap(([[state, currentQuery], isDelayed, infinityArray]) => {\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 !== null &&\n              instance.currentPage !== null &&\n              instance.totalPages > instance.currentPage) ||\n            false;\n          this._viewContext.currentCalculatedPage = instance.currentCalculatedPage;\n          this._viewContext.currentQuery = currentQuery;\n\n          if (isQueryStateLoading(state) || isDelayed || !infinityArray) {\n            this._viewContext.loading = state ? state.meta.triggeredVia !== 'poll' : 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            this._viewContext.etInfinityQuery = this._viewContext.$implicit =\n              infinityArray as Q['response']['arrayType'];\n            this._data$.next(infinityArray);\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 _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,123 @@
+import { ChangeDetectorRef, Directive, ErrorHandler, Input, TemplateRef, ViewContainerRef, inject, } from '@angular/core';
+import { tap } from 'rxjs';
+import { extractQuery, isQueryCollection, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, } from '../query';
+import * as i0 from "@angular/core";
+export class QueryDirective {
+    constructor() {
+        this._mainTemplateRef = inject(TemplateRef);
+        this._viewContainerRef = inject(ViewContainerRef);
+        this._errorHandler = inject(ErrorHandler);
+        this._cdr = inject(ChangeDetectorRef);
+        this._isMainViewCreated = false;
+        this._subscription = null;
+        this._viewContext = {
+            $implicit: null,
+            etQuery: null,
+            loading: false,
+            refreshing: false,
+            error: null,
+            progress: null,
+            scope: null,
+            query: null,
+        };
+        this._cache = false;
+    }
+    get query() {
+        return this._query;
+    }
+    set query(v) {
+        this._query = v;
+        this._subscribeToQuery();
+    }
+    get cache() {
+        return this._cache;
+    }
+    set cache(v) {
+        this._cache = v;
+    }
+    static ngTemplateContextGuard(dir, ctx) {
+        return true;
+    }
+    ngOnInit() {
+        this._renderMainView();
+    }
+    ngOnDestroy() {
+        this._subscription?.unsubscribe();
+    }
+    _subscribeToQuery() {
+        this._subscription?.unsubscribe();
+        this._subscription = null;
+        const query = extractQuery(this.query);
+        if (!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;
+            this._viewContext.scope = null;
+            this._viewContext.query = null;
+            return;
+        }
+        if (isQueryStatePrepared(query.rawState) || isQueryStateCancelled(query.rawState)) {
+            query.execute();
+        }
+        const sub = query.state$.pipe(tap((state) => this._updateView(state))).subscribe();
+        this._viewContext.scope = isQueryCollection(query) ? query.type : null;
+        this._viewContext.query = query;
+        this._subscription = sub;
+    }
+    _updateView(state) {
+        if (isQueryStateLoading(state)) {
+            this._viewContext.progress = state.progress ?? null;
+            this._viewContext.refreshing = state.meta.triggeredVia === 'auto' || state.meta.triggeredVia === 'poll';
+            if (!this._viewContext.refreshing) {
+                this._viewContext.loading = true;
+            }
+        }
+        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: "18.1.1", ngImport: i0, type: QueryDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: QueryDirective, isStandalone: true, selector: "[etQuery]", inputs: { query: ["etQuery", "query"], cache: ["etQueryCache", "cache"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: QueryDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[etQuery]',
+                    standalone: true,
+                }]
+        }], 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  inject,\n} from '@angular/core';\nimport { Subscription, tap } from 'rxjs';\nimport {\n  AnyQuery,\n  AnyQueryCollection,\n  QueryCollectionKeysOf,\n  QueryOf,\n  QueryState,\n  extractQuery,\n  isQueryCollection,\n  isQueryStateCancelled,\n  isQueryStateFailure,\n  isQueryStateLoading,\n  isQueryStatePrepared,\n  isQueryStateSuccess,\n} from '../query';\nimport { QueryDataOf } from '../query-creator';\nimport { RequestError, RequestProgress } from '../request';\n\ninterface QueryContext<Q extends AnyQuery | AnyQueryCollection | null> {\n  /**\n   * The queries's response data.\n   */\n  $implicit: QueryDataOf<QueryOf<Q>> | null;\n\n  /**\n   * The queries's response data.\n   */\n  etQuery: QueryDataOf<QueryOf<Q>> | null;\n\n  /**\n   * The query used inside this directive. Useful if for instance the query gets unwrapped via async pipe inside the directive.\n   */\n  query: QueryOf<Q> | null;\n\n  /**\n   * Is true when the query is triggered by user interaction.\n   */\n  loading: boolean;\n\n  /**\n   * Is true when the query is triggered by either polling or auto refresh event.\n   */\n  refreshing: boolean;\n\n  /**\n   * The query's progress state.\n   */\n  progress: RequestProgress | null;\n\n  /**\n   * The query's error state.\n   */\n  error: RequestError<unknown> | null;\n\n  /**\n   * The query's scope (only available when the query is a collection)\n   */\n  scope: QueryCollectionKeysOf<Q> | 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 _mainTemplateRef = inject<TemplateRef<QueryContext<Q>>>(TemplateRef);\n  private _viewContainerRef = inject(ViewContainerRef);\n  private _errorHandler = inject(ErrorHandler);\n  private _cdr = inject(ChangeDetectorRef);\n\n  private _isMainViewCreated = false;\n  private _subscription: Subscription | null = null;\n\n  private readonly _viewContext: QueryContext<Q> = {\n    $implicit: null,\n    etQuery: null,\n    loading: false,\n    refreshing: false,\n    error: null,\n    progress: null,\n    scope: null,\n    query: 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  static ngTemplateContextGuard<Q extends AnyQuery | AnyQueryCollection | null>(\n    dir: QueryDirective<Q>,\n    ctx: unknown,\n  ): ctx is QueryContext<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    const query = extractQuery(this.query);\n\n    if (!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      this._viewContext.scope = null;\n      this._viewContext.query = null;\n      return;\n    }\n\n    if (isQueryStatePrepared(query.rawState) || isQueryStateCancelled(query.rawState)) {\n      query.execute();\n    }\n\n    const sub = query.state$.pipe(tap((state) => this._updateView(state))).subscribe();\n\n    this._viewContext.scope = isQueryCollection(query) ? (query.type as QueryCollectionKeysOf<Q>) : null;\n    this._viewContext.query = query as QueryOf<Q>;\n\n    this._subscription = sub;\n  }\n\n  private _updateView(state: QueryState) {\n    if (isQueryStateLoading(state)) {\n      this._viewContext.progress = state.progress ?? null;\n      this._viewContext.refreshing = state.meta.triggeredVia === 'auto' || state.meta.triggeredVia === 'poll';\n\n      if (!this._viewContext.refreshing) {\n        this._viewContext.loading = true;\n      }\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/entity/entity-store.mjs

@@ -0,0 +1,127 @@
+import { Subject, debounceTime, filter, map, shareReplay, startWith } from 'rxjs';
+class EntityStoreError extends Error {
+    constructor(message, detail) {
+        super(message);
+        this.detail = detail;
+        this.name = 'EntityStoreError';
+    }
+}
+function flatten(arr) {
+    return arr.reduce((acc, val) => acc.concat(val), []);
+}
+export class EntityStore {
+    constructor(_config) {
+        this._config = _config;
+        /**
+         * @internal
+         */
+        this._dictionary = new Map();
+        /**
+         * @internal
+         */
+        this._change$ = new Subject();
+    }
+    select(keyOrKeys) {
+        if (Array.isArray(keyOrKeys)) {
+            const _keys = this._normalizeKeys(keyOrKeys);
+            return this._selectMany(_keys);
+        }
+        return this._select(keyOrKeys);
+    }
+    /**
+     * **Note:** Prefer `select` over `selectWhere` when possible.
+     */
+    selectWhere(predicate) {
+        return this._change$.pipe(startWith(null), debounceTime(0), map(() => Array.from(this._dictionary.values()).filter(predicate)), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    set(keyOrKeys, valueOrValues) {
+        const _keys = this._normalizeKeys(keyOrKeys);
+        if (Array.isArray(_keys)) {
+            if (!Array.isArray(valueOrValues)) {
+                throw new EntityStoreError('When setting multiple keys, values must be an array', {
+                    keyOrValues: _keys,
+                    valueOrValues,
+                });
+            }
+            const _values = (Array.isArray(valueOrValues[0]) ? flatten(valueOrValues) : valueOrValues);
+            for (let i = 0; i < _keys.length; i++) {
+                const k = _keys[i];
+                const v = _values[i];
+                if (k === undefined || v === undefined)
+                    continue;
+                this._set(k, v);
+            }
+        }
+        else {
+            this._set(_keys, valueOrValues);
+        }
+        this._change$.next(_keys);
+    }
+    remove(keyOrKeys) {
+        const _keys = this._normalizeKeys(keyOrKeys);
+        if (Array.isArray(_keys)) {
+            for (const key of _keys) {
+                this._remove(key);
+            }
+        }
+        else {
+            this._remove(_keys);
+        }
+        this._change$.next(_keys);
+    }
+    logState() {
+        console.log('EntityStore:', this._config.name, {
+            dictionary: this._dictionary,
+        });
+    }
+    _select(key) {
+        if (this._config.logActions) {
+            console.log('EntityStore: select', this._config.name, key);
+        }
+        return this._change$.pipe(startWith(null), filter((v) => {
+            if (v === null) {
+                return true;
+            }
+            if (Array.isArray(v)) {
+                return v.includes(key);
+            }
+            return v === key;
+        }), map(() => this._dictionary.get(key) ?? null));
+    }
+    _selectMany(keys) {
+        if (this._config.logActions) {
+            console.log('EntityStore: selectMany', this._config.name, keys);
+        }
+        return this._change$.pipe(startWith(null), filter((v) => {
+            if (v === null) {
+                return true;
+            }
+            if (Array.isArray(v)) {
+                return keys.some((key) => v.includes(key));
+            }
+            return keys.includes(v);
+        }), map(() => keys.map((key) => this._dictionary.get(key)).filter((value) => value !== undefined)));
+    }
+    _set(key, value) {
+        if (this._config.logActions) {
+            console.log('EntityStore: set', this._config.name, key, value);
+        }
+        this._dictionary.set(key, value);
+    }
+    _remove(key) {
+        if (this._config.logActions) {
+            console.log('EntityStore: remove', this._config.name, key);
+        }
+        this._dictionary.delete(key);
+    }
+    _normalizeKeys(keys) {
+        if (Array.isArray(keys)) {
+            if (Array.isArray(keys[0])) {
+                return flatten(keys);
+            }
+            return keys;
+        }
+        return keys;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-store.js","sourceRoot":"","sources":["../../../../../../libs/query/src/lib/entity/entity-store.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subject, debounceTime, filter, map, shareReplay, startWith } from 'rxjs';\nimport { EntityKey, EntityStoreConfig } from './entity.types';\n\nclass EntityStoreError extends Error {\n  constructor(\n    message: string,\n    public detail?: unknown,\n  ) {\n    super(message);\n    this.name = 'EntityStoreError';\n  }\n}\n\nfunction flatten<T>(arr: T[][]): T[] {\n  return arr.reduce((acc, val) => acc.concat(val), []);\n}\n\nexport class EntityStore<T> {\n  /**\n   * @internal\n   */\n  readonly _dictionary = new Map<EntityKey, T>();\n\n  /**\n   * @internal\n   */\n  readonly _change$ = new Subject<EntityKey | EntityKey[]>();\n\n  constructor(private readonly _config: EntityStoreConfig) {}\n\n  select(key: EntityKey): Observable<T | null>;\n  select(keys: EntityKey[]): Observable<T[]>;\n  select(keys: EntityKey[][]): Observable<T[]>;\n  select(keyOrKeys: EntityKey | EntityKey[] | EntityKey[][]): Observable<T | null> | Observable<T[]> {\n    if (Array.isArray(keyOrKeys)) {\n      const _keys = this._normalizeKeys(keyOrKeys);\n      return this._selectMany(_keys as EntityKey[]);\n    }\n\n    return this._select(keyOrKeys);\n  }\n\n  /**\n   * **Note:** Prefer `select` over `selectWhere` when possible.\n   */\n  selectWhere(predicate: (value: T) => boolean): Observable<T[]> {\n    return this._change$.pipe(\n      startWith(null),\n      debounceTime(0),\n      map(() => Array.from(this._dictionary.values()).filter(predicate)),\n      shareReplay({ bufferSize: 1, refCount: true }),\n    );\n  }\n\n  set(key: EntityKey, value: T): void;\n  set(keys: EntityKey[], values: T[]): void;\n  set(keys: EntityKey[][], values: T[][]): void;\n  set(keyOrKeys: EntityKey | EntityKey[] | EntityKey[][], valueOrValues: T | T[] | T[][]) {\n    const _keys = this._normalizeKeys(keyOrKeys);\n\n    if (Array.isArray(_keys)) {\n      if (!Array.isArray(valueOrValues)) {\n        throw new EntityStoreError('When setting multiple keys, values must be an array', {\n          keyOrValues: _keys,\n          valueOrValues,\n        });\n      }\n\n      const _values = (Array.isArray(valueOrValues[0]) ? flatten(valueOrValues as T[][]) : valueOrValues) as T[];\n\n      for (let i = 0; i < _keys.length; i++) {\n        const k = _keys[i];\n        const v = _values[i];\n\n        if (k === undefined || v === undefined) continue;\n\n        this._set(k, v);\n      }\n    } else {\n      this._set(_keys, valueOrValues as T);\n    }\n\n    this._change$.next(_keys);\n  }\n\n  remove(key: EntityKey): void;\n  remove(keys: EntityKey[]): void;\n  remove(keys: EntityKey[][]): void;\n  remove(keyOrKeys: EntityKey | EntityKey[] | EntityKey[][]) {\n    const _keys = this._normalizeKeys(keyOrKeys);\n\n    if (Array.isArray(_keys)) {\n      for (const key of _keys) {\n        this._remove(key);\n      }\n    } else {\n      this._remove(_keys);\n    }\n\n    this._change$.next(_keys);\n  }\n\n  logState() {\n    console.log('EntityStore:', this._config.name, {\n      dictionary: this._dictionary,\n    });\n  }\n\n  private _select(key: EntityKey): Observable<T | null> {\n    if (this._config.logActions) {\n      console.log('EntityStore: select', this._config.name, key);\n    }\n\n    return this._change$.pipe(\n      startWith(null),\n      filter((v) => {\n        if (v === null) {\n          return true;\n        }\n\n        if (Array.isArray(v)) {\n          return v.includes(key);\n        }\n\n        return v === key;\n      }),\n      map(() => this._dictionary.get(key) ?? null),\n    );\n  }\n\n  private _selectMany(keys: EntityKey[]): Observable<T[]> {\n    if (this._config.logActions) {\n      console.log('EntityStore: selectMany', this._config.name, keys);\n    }\n\n    return this._change$.pipe(\n      startWith(null),\n      filter((v) => {\n        if (v === null) {\n          return true;\n        }\n\n        if (Array.isArray(v)) {\n          return keys.some((key) => v.includes(key));\n        }\n\n        return keys.includes(v);\n      }),\n      map(() => keys.map((key) => this._dictionary.get(key)).filter((value): value is T => value !== undefined)),\n    );\n  }\n\n  private _set(key: EntityKey, value: T) {\n    if (this._config.logActions) {\n      console.log('EntityStore: set', this._config.name, key, value);\n    }\n\n    this._dictionary.set(key, value);\n  }\n\n  private _remove(key: EntityKey) {\n    if (this._config.logActions) {\n      console.log('EntityStore: remove', this._config.name, key);\n    }\n\n    this._dictionary.delete(key);\n  }\n\n  private _normalizeKeys(keys: EntityKey | EntityKey[] | EntityKey[][]): EntityKey | EntityKey[] {\n    if (Array.isArray(keys)) {\n      if (Array.isArray(keys[0])) {\n        return flatten(keys as EntityKey[][]);\n      }\n\n      return keys as EntityKey[];\n    }\n\n    return keys;\n  }\n}\n"]}

package/esm2022/lib/entity/entity.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9xdWVyeS9zcmMvbGliL2VudGl0eS9lbnRpdHkudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIEVudGl0eUtleSA9IHN0cmluZyB8IG51bWJlcjtcblxuZXhwb3J0IGludGVyZmFjZSBFbnRpdHlTdG9yZUNvbmZpZyB7XG4gIG5hbWU6IHN0cmluZztcbiAgbG9nQWN0aW9ucz86IGJvb2xlYW47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSW5zZXJ0RnJvbUNvbmZpZzxcbiAgT3JpZ2luU3RvcmVUeXBlLFxuICBPcmlnaW5LZXlzIGV4dGVuZHMga2V5b2YgTm9uTnVsbGFibGU8T3JpZ2luU3RvcmVUeXBlPixcbiAgSWRGbiBleHRlbmRzICh2YWx1ZTogTm9uTnVsbGFibGU8T3JpZ2luU3RvcmVUeXBlPikgPT4gRW50aXR5S2V5IHwgRW50aXR5S2V5W10sXG4+IHtcbiAgLyoqXG4gICAqIFRoZSBwcm9wZXJ0eSBrZXkgb2Ygd2hpY2ggdGhlIHZhbHVlIHNob3VsZCBiZSByZXBsYWNlZC5cbiAgICovXG4gIGZvcjogT3JpZ2luS2V5cztcblxuICAvKipcbiAgICogQSBmdW5jdGlvbiB0aGF0IHJldHVybnMgdGhlIGlkIG9mIHRoZSBlbnRpdHkuIENhbiBhbHNvIHJldHVybiBhbiBhcnJheSBvZiBpZHMuXG4gICAqL1xuICBpZDogSWRGbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBSZW1vdmVGcm9tQ29uZmlnPFQ+IHtcbiAgLyoqXG4gICAqIFRoZSB3aGVyZSBmdW5jdGlvbiB0byBzZWxlY3QgdGhlIGVudGl0aWVzIHRvIHJlbW92ZS5cbiAgICovXG4gIHdoZXJlOiAoZW50aXR5OiBUKSA9PiBib29sZWFuO1xuXG4gIC8qKlxuICAgKiBBIGZ1bmN0aW9uIHRoYXQgcmV0dXJucyB0aGUgaWQgb2YgdGhlIGVudGl0eS5cbiAgICovXG4gIGlkOiAoZW50aXR5OiBUKSA9PiBFbnRpdHlLZXk7XG59XG4iXX0=

package/esm2022/lib/entity/entity.utils.mjs

@@ -0,0 +1,29 @@
+import { map, of, switchMap, take, tap } from 'rxjs';
+export function mapToPaginated(response) {
+    return map((items) => ({ ...response, items }));
+}
+// FIXME: This breaks if SubStoreType is an array
+/**
+ * Use an other store to represent a property of the current entity.
+ */
+export const insertFrom = (store, { for: key, id }) => switchMap((value) => {
+    if (!value)
+        return of(null);
+    const ids = id(value);
+    if (Array.isArray(ids)) {
+        return store.select(ids).pipe(map((data) => ({ ...value, [key]: data })));
+    }
+    else {
+        return store.select(ids).pipe(map((data) => ({ ...value, [key]: data })));
+    }
+});
+/**
+ * Remove entities from a store based on a where function.
+ */
+export const removeFrom = (store, { where, id }) => {
+    store
+        .selectWhere(where)
+        .pipe(tap((entities) => store.remove(entities.map(id))), take(1))
+        .subscribe();
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/entity/index.mjs

@@ -0,0 +1,4 @@
+export * from './entity-store';
+export * from './entity.types';
+export * from './entity.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3F1ZXJ5L3NyYy9saWIvZW50aXR5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lbnRpdHktc3RvcmUnO1xuZXhwb3J0ICogZnJvbSAnLi9lbnRpdHkudHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9lbnRpdHkudXRpbHMnO1xuIl19

package/esm2022/lib/gql/gql.mjs

@@ -0,0 +1,23 @@
+const getOpName = /(query|mutation) ?([\w\d-_]+)? ?\(.*?\)? \{/;
+export const transformGql = (str) => {
+    str = Array.isArray(str) ? str.join('') : str;
+    const name = getOpName.exec(str);
+    return function (variables) {
+        const data = { query: str };
+        if (variables)
+            data['variables'] = JSON.stringify(variables);
+        if (name && name.length) {
+            const operationName = name[2];
+            if (operationName)
+                data['operationName'] = name[2];
+        }
+        return data;
+    };
+};
+export const gql = (strings, ...values) => {
+    const str = strings.reduce((acc, cur, i) => {
+        return acc + cur + (values[i] || '');
+    }, '');
+    return str;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/gql/index.mjs

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

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

@@ -0,0 +1,4 @@
+export * from './infinity-query';
+export * from './infinity-query.types';
+export * from './infinity-query.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3F1ZXJ5L3NyYy9saWIvaW5maW5pdGUtcXVlcnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2luZmluaXR5LXF1ZXJ5JztcbmV4cG9ydCAqIGZyb20gJy4vaW5maW5pdHktcXVlcnkudHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9pbmZpbml0eS1xdWVyeS51dGlscyc7XG4iXX0=