@tstdl/base 0.90.85 → 0.90.89

package/api/client/client.js

@@ -93,14 +93,8 @@ function getRequestBody(body) {
     if (isUndefined(body)) {
         return undefined;
     }
-    if (isUint8Array(body)) {
-        return { buffer: body };
-    }
-    if (isReadableStream(body)) {
-        return { stream: body };
-    }
-    if (isBlob(body)) {
-        return { blob: body };
+    if (isUint8Array(body) || isReadableStream(body) || isBlob(body)) {
+        return { binary: body };
     }
     if (isString(body)) {
         return { text: body };

package/data-structures/collection.d.ts

@@ -1,56 +1,56 @@
 import type { ToJson } from '../interfaces.js';
-import type { Observable } from 'rxjs';
+import { type Observable } from 'rxjs';
 export declare abstract class Collection<T, TThis extends Collection<T, TThis> = Collection<T, any>> implements Iterable<T>, ToJson {
     private readonly sizeSubject;
     private readonly changeSubject;
     private readonly clearSubject;
-    /** emits collection on subscribe and change */
+    /** Emits collection on subscribe and change */
     readonly observe$: Observable<TThis>;
-    /** emits size of collection */
+    /** Emits size of collection */
     readonly size$: Observable<number>;
-    /** emits collection on change */
+    /** Emits collection on change */
     readonly change$: Observable<TThis>;
     readonly clear$: Observable<TThis>;
-    /** emits when the collection is empty */
+    /** Emits when the collection is empty */
     readonly onEmpty$: Observable<void>;
-    /** emits when the collection has items */
+    /** Emits when the collection has items */
     readonly onItems$: Observable<void>;
-    /** emits whether the collection is empty */
+    /** Emits whether the collection is empty */
     readonly isEmpty$: Observable<boolean>;
-    /** emits whether the collection has items */
+    /** Emits whether the collection has items */
     readonly hasItems$: Observable<boolean>;
-    /** resolves when the collection is empty */
+    /** Resolves when the collection is empty */
     get $onEmpty(): Promise<void>;
-    /** resolves when the collection has items */
+    /** Resolves when the collection has items */
     get $onItems(): Promise<void>;
-    /** size of collection */
+    /** Size of collection */
     get size(): number;
-    /** whether the collection is empty */
+    /** Whether the collection is empty */
     get isEmpty(): boolean;
-    /** whether the collection has items */
+    /** Whether the collection has items */
     get hasItems(): boolean;
     constructor();
     [Symbol.iterator](): IterableIterator<T>;
     toArray(): T[];
     toJSON(): T[];
-    /** remove all items */
+    /** Remove all items */
     clear(): void;
-    /** sets collection size */
+    /** Sets collection size */
     protected setSize(size: number): void;
-    /** increment collection size by amount (default 1) */
+    /** Increment collection size by amount (default 1) */
     protected incrementSize(amount?: number): void;
-    /** decrement collection size by amount (default 1) */
+    /** Decrement collection size by amount (default 1) */
     protected decrementSize(amount?: number): void;
     protected emitChange(): void;
     abstract includes(item: T): boolean;
-    /** add item to collection */
+    /** Add item to collection */
     abstract add(item: T): void;
-    /** add many items to collection */
+    /** Add many items to collection */
     abstract addMany(items: Iterable<T>): void;
-    /** clone collection */
+    /** Clone collection */
     abstract clone(): TThis;
-    /** yields all items from the collection */
+    /** Yields all items from the collection */
     abstract items(): IterableIterator<T>;
-    /** clear all data - size is set to 0 automatically */
+    /** Clear all data - size is set to 0 automatically */
     protected abstract _clear(): void;
 }

package/data-structures/collection.js

@@ -1,41 +1,41 @@
-import { BehaviorSubject, distinctUntilChanged, filter, firstValueFrom, map, startWith, Subject } from 'rxjs';
+import { BehaviorSubject, Subject, distinctUntilChanged, filter, firstValueFrom, map, startWith } from 'rxjs';
 export class Collection {
     sizeSubject;
     changeSubject;
     clearSubject;
-    /** emits collection on subscribe and change */
+    /** Emits collection on subscribe and change */
     observe$;
-    /** emits size of collection */
+    /** Emits size of collection */
     size$;
-    /** emits collection on change */
+    /** Emits collection on change */
     change$;
-    /* emits collection on clear */
+    /* Emits collection on clear */
     clear$;
-    /** emits when the collection is empty */
+    /** Emits when the collection is empty */
     onEmpty$;
-    /** emits when the collection has items */
+    /** Emits when the collection has items */
     onItems$;
-    /** emits whether the collection is empty */
+    /** Emits whether the collection is empty */
     isEmpty$;
-    /** emits whether the collection has items */
+    /** Emits whether the collection has items */
     hasItems$;
-    /** resolves when the collection is empty */
+    /** Resolves when the collection is empty */
     get $onEmpty() {
         return firstValueFrom(this.onEmpty$);
     }
-    /** resolves when the collection has items */
+    /** Resolves when the collection has items */
     get $onItems() {
         return firstValueFrom(this.onItems$);
     }
-    /** size of collection */
+    /** Size of collection */
     get size() {
         return this.sizeSubject.value;
     }
-    /** whether the collection is empty */
+    /** Whether the collection is empty */
     get isEmpty() {
         return this.size == 0;
     }
-    /** whether the collection has items */
+    /** Whether the collection has items */
     get hasItems() {
         return this.size > 0;
     }
@@ -61,24 +61,24 @@ export class Collection {
     toJSON() {
         return this.toArray();
     }
-    /** remove all items */
+    /** Remove all items */
     clear() {
         this._clear();
         this.clearSubject.next(this);
         this.setSize(0);
     }
-    /** sets collection size */
+    /** Sets collection size */
     setSize(size) {
         if (size != this.size) {
             this.sizeSubject.next(size);
             this.emitChange();
         }
     }
-    /** increment collection size by amount (default 1) */
+    /** Increment collection size by amount (default 1) */
     incrementSize(amount = 1) {
         this.setSize(this.size + amount);
     }
-    /** decrement collection size by amount (default 1) */
+    /** Decrement collection size by amount (default 1) */
     decrementSize(amount = 1) {
         this.setSize(this.size - amount);
     }

package/data-structures/iterable-weak-map.d.ts

@@ -5,7 +5,7 @@ export declare class IterableWeakMap<K extends object, V> extends Collection<[K,
     private finalizationRegistry;
     readonly [Symbol.toStringTag] = "IterableWeakMap";
     /**
-     * provides the real size. This is slow because it requires a cleanup iteration
+     * Provides the real size. This is slow because it requires a cleanup iteration
      */
     get realSize(): number;
     static get supported(): boolean;
@@ -17,7 +17,7 @@ export declare class IterableWeakMap<K extends object, V> extends Collection<[K,
     addMany(values: Iterable<readonly [K, V]>): void;
     set(key: K, value: V): this;
     delete(key: K): boolean;
-    /** prune garbage collected entries */
+    /** Prune garbage collected entries */
     cleanup(): void;
     clone(): IterableWeakMap<K, V>;
     forEach(callback: (value: V, key: K, map: IterableWeakMap<K, V>) => void, thisArg?: any): void;

package/data-structures/iterable-weak-map.js

@@ -9,7 +9,7 @@ export class IterableWeakMap extends Collection {
     finalizationRegistry;
     [Symbol.toStringTag] = 'IterableWeakMap';
     /**
-     * provides the real size. This is slow because it requires a cleanup iteration
+     * Provides the real size. This is slow because it requires a cleanup iteration
      */
     get realSize() {
         this.cleanup();
@@ -79,7 +79,7 @@ export class IterableWeakMap extends Collection {
         }
         return deleted;
     }
-    /** prune garbage collected entries */
+    /** Prune garbage collected entries */
     cleanup() {
         drain(this);
         this.updateSize();

package/database/query.d.ts

@@ -1,4 +1,4 @@
-import type { Flatten, StringMap } from '../types.js';
+import type { Flatten, Record } from '../types.js';
 import type { Geometry } from '../types/geo-json.js';
 export type QueryOptions<T = any> = {
     sort?: Sort<T>[];
@@ -10,7 +10,7 @@ export type LogicalQueryTypes = keyof (LogicalAndQuery & LogicalOrQuery & Logica
 export declare const allLogicalQueryTypes: LogicalQueryTypes[];
 export type ComparisonQueryBody<T = any> = {
     [P in keyof T]?: ComparisonQueryOrValue<T[P]>;
-} & StringMap<ComparisonQueryOrValue>;
+} & Record<ComparisonQueryOrValue>;
 export type ComparisonQueryOrValue<T = any> = ComparisonQuery<T> | T | Flatten<T>;
 export type ComparisonQuery<T = any> = Partial<ComparisonNotQuery<T> & ComparisonEqualsQuery<T> & ComparisonNotEqualsQuery<T> & ComparisonExistsQuery & ComparisonItemQuery<T> & ComparisonInQuery<T> & ComparisonNotInQuery<T> & ComparisonAllQuery<T> & ComparisonGreaterThanQuery<T> & ComparisonGreaterThanOrEqualsQuery<T> & ComparisonLessThanQuery<T> & ComparisonLessThanOrEqualsQuery<T> & ComparisonRegexQuery & ComparisonTextQuery & ComparisonGeoShapeQuery & ComparisonGeoDistanceQuery>;
 export type ComparisonQueryTypes = keyof ComparisonQuery;
@@ -100,11 +100,11 @@ export type ComparisonGeoDistanceQuery = {
         longitude: number;
         latitude: number;
         /**
-         * maximum distance in meters
+         * Maximum distance in meters
          */
         maxDistance?: number;
         /**
-         * minimum distance in meters
+         * Minimum distance in meters
          */
         minDistance?: number;
     };

package/dom/observation/intersection-observer.d.ts

@@ -1,9 +1,4 @@
-import { Signal } from '../../signals/api.js';
-import { Observable } from 'rxjs';
-export type ObserveIntersectionOptions = IntersectionObserverInit & {
-    takeRecordsTrigger?: Observable<any>;
-    observeTrigger?: Observable<Element>;
-    unobserveTrigger?: Observable<Element>;
-};
-export declare function observeIntersection$(elements: Element | Element[], options?: ObserveIntersectionOptions): Observable<IntersectionObserverEntry[]>;
-export declare function observeIntersection(elements: Element | Element[], options?: ObserveIntersectionOptions): Signal<IntersectionObserverEntry[]>;
+import { type Signal } from '../../signals/api.js';
+import { type Observable } from 'rxjs';
+export declare function observeIntersection$(element: Element, options?: IntersectionObserverInit): Observable<IntersectionObserverEntry>;
+export declare function observeIntersection(elements: Element, options?: IntersectionObserverInit): Signal<IntersectionObserverEntry | undefined>;

package/dom/observation/intersection-observer.js

@@ -1,31 +1,26 @@
+import { IterableWeakMap } from '../../data-structures/iterable-weak-map.js';
 import { toSignal } from '../../signals/api.js';
-import { toArray } from '../../utils/array/array.js';
-import { isDefined } from '../../utils/type-guards.js';
-import { Observable } from 'rxjs';
-export function observeIntersection$(elements, options = {}) {
-    const { takeRecordsTrigger, observeTrigger, unobserveTrigger, ...init } = options;
-    return new Observable((subscriber) => {
-        const observer = new IntersectionObserver((entries) => subscriber.next(entries), init);
-        const subscriptions = [];
-        for (const element of toArray(elements)) {
+import { FactoryMap } from '../../utils/factory-map.js';
+import { isDefined, isNumber } from '../../utils/type-guards.js';
+import { Subject, filter, fromEventPattern, map, shareReplay } from 'rxjs';
+const observerMap = new FactoryMap((root) => new FactoryMap((rootMargin) => new FactoryMap((threshold) => {
+    const observer = new IntersectionObserver((entries) => subject.next(entries), { root, rootMargin, threshold });
+    const subject = new Subject;
+    return ({
+        observer,
+        subject,
+        elementObservables: new FactoryMap((element) => fromEventPattern((handler) => {
             observer.observe(element);
-        }
-        if (isDefined(takeRecordsTrigger)) {
-            subscriptions.push(takeRecordsTrigger.subscribe({ next: () => subscriber.next(observer.takeRecords()) }));
-        }
-        if (isDefined(observeTrigger)) {
-            subscriptions.push(observeTrigger.subscribe({ next: (element) => observer.observe(element) }));
-        }
-        if (isDefined(unobserveTrigger)) {
-            subscriptions.push(unobserveTrigger.subscribe({ next: (element) => observer.unobserve(element) }));
-        }
-        subscriber.next(observer.takeRecords());
-        return () => {
-            observer.disconnect();
-            subscriptions.forEach((subscription) => subscription.unsubscribe());
-        };
+            return subject.pipe(map((entries) => entries.find((entry) => entry.target == element)), filter(isDefined)).subscribe((entry) => handler(entry));
+        }, (_, subscription) => {
+            observer.unobserve(element);
+            subscription.unsubscribe();
+        }).pipe(shareReplay({ bufferSize: 1, refCount: true })), new IterableWeakMap())
     });
+}, undefined, (threshold) => isNumber(threshold) ? threshold : threshold?.join(','))));
+export function observeIntersection$(element, options) {
+    return observerMap.get(options?.root).get(options?.rootMargin).get(options?.threshold).elementObservables.get(element);
 }
 export function observeIntersection(elements, options) {
-    return toSignal(observeIntersection$(elements, options), { requireSync: true });
+    return toSignal(observeIntersection$(elements, options));
 }

package/dom/observation/resize-observer.d.ts

@@ -1,8 +1,4 @@
-import { Signal } from '../../signals/api.js';
-import { Observable } from 'rxjs';
-export type ObserveResizeOptions = ResizeObserverOptions & {
-    observeTrigger?: Observable<Element>;
-    unobserveTrigger?: Observable<Element>;
-};
-export declare function observeResize$(elements: Element | (Element | [Element, ResizeObserverOptions])[], options?: ObserveResizeOptions): Observable<ResizeObserverEntry[]>;
-export declare function observeResize(elements: Element | (Element | [Element, ResizeObserverOptions])[], options?: ObserveResizeOptions): Signal<ResizeObserverEntry[]>;
+import { type Signal } from '../../signals/api.js';
+import { type Observable } from 'rxjs';
+export declare function observeResize$(element: Element, options?: ResizeObserverOptions): Observable<ResizeObserverEntry>;
+export declare function observeResize(elements: Element, options?: ResizeObserverOptions): Signal<ResizeObserverEntry | undefined>;

package/dom/observation/resize-observer.js

@@ -1,35 +1,29 @@
+import { IterableWeakMap } from '../../data-structures/iterable-weak-map.js';
 import { toSignal } from '../../signals/api.js';
-import { toArray } from '../../utils/array/array.js';
-import { isArray, isDefined } from '../../utils/type-guards.js';
-import { Observable } from 'rxjs';
-export function observeResize$(elements, options = {}) {
-    const { observeTrigger, unobserveTrigger, ...defaultOptions } = options;
-    return new Observable((subscriber) => {
-        const observer = new ResizeObserver((entries) => subscriber.next(entries));
-        const subscriptions = [];
-        for (const element of toArray(elements)) {
-            observe(observer, element, defaultOptions);
-        }
-        if (isDefined(observeTrigger)) {
-            subscriptions.push(observeTrigger.subscribe({ next: (element) => observe(observer, element, defaultOptions) }));
-        }
-        if (isDefined(unobserveTrigger)) {
-            subscriptions.push(unobserveTrigger.subscribe({ next: (element) => observer.unobserve(element) }));
-        }
-        return () => {
-            observer.disconnect();
-            subscriptions.forEach((subscription) => subscription.unsubscribe());
-        };
-    });
+import { FactoryMap } from '../../utils/factory-map.js';
+import { isDefined } from '../../utils/type-guards.js';
+import { Subject, filter, fromEventPattern, map, shareReplay } from 'rxjs';
+let observer;
+let subject;
+const elementObservablesMap = new FactoryMap(() => ({}), new IterableWeakMap());
+export function observeResize$(element, options) {
+    const box = options?.box ?? 'undefined';
+    const elementObservables = elementObservablesMap.get(element);
+    if (isDefined(elementObservables) && isDefined(elementObservables[box])) {
+        return elementObservables[box];
+    }
+    subject ??= new Subject();
+    observer ??= new ResizeObserver((entries) => subject.next(entries));
+    const elementResize$ = fromEventPattern((handler) => {
+        observer.observe(element, options);
+        return subject.pipe(map((entries) => entries.find((entry) => entry.target == element)), filter(isDefined)).subscribe((entry) => handler(entry));
+    }, (_, subscription) => {
+        observer.unobserve(element);
+        subscription.unsubscribe();
+    }).pipe(shareReplay({ bufferSize: 1, refCount: true }));
+    elementObservables[box] = elementResize$;
+    return elementResize$;
 }
 export function observeResize(elements, options) {
-    return toSignal(observeResize$(elements, options), { requireSync: true });
-}
-function observe(observer, element, defaultOptions) {
-    if (isArray(element)) {
-        observer.observe(element[0], element[1] ?? defaultOptions);
-    }
-    else {
-        observer.observe(element, defaultOptions);
-    }
+    return toSignal(observeResize$(elements, options));
 }

package/http/client/adapters/undici.adapter.js

@@ -11,7 +11,7 @@ import { HttpError, HttpErrorReason } from '../../../http/http.error.js';
 import { Singleton, injectArgument, resolveArgumentType } from '../../../injector/index.js';
 import { Injector } from '../../../injector/injector.js';
 import { toArray } from '../../../utils/array/array.js';
-import { isDefined } from '../../../utils/type-guards.js';
+import { isBlob, isDefined, isUint8Array } from '../../../utils/type-guards.js';
 import { HttpClientResponse } from '../http-client-response.js';
 import { HttpClientAdapter } from '../http-client.adapter.js';
 let defaultOptions = {};
@@ -26,14 +26,15 @@ let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAd
         else if (isDefined(httpClientRequest.body?.text)) {
             body = httpClientRequest.body.text;
         }
-        else if (isDefined(httpClientRequest.body?.buffer)) {
-            body = httpClientRequest.body.buffer;
-        }
-        else if (isDefined(httpClientRequest.body?.blob)) {
-            body = Readable.from(httpClientRequest.body.blob.stream());
-        }
-        else if (isDefined(httpClientRequest.body?.stream)) {
-            body = Readable.from(httpClientRequest.body.stream);
+        else if (isDefined(httpClientRequest.body?.binary)) {
+            if (isBlob(httpClientRequest.body.binary)) {
+                body = Readable.from(httpClientRequest.body.binary.stream());
+            }
+            else {
+                body = isUint8Array(httpClientRequest.body.binary)
+                    ? httpClientRequest.body.binary
+                    : Readable.from(httpClientRequest.body.binary);
+            }
         }
         else if (isDefined(httpClientRequest.body?.form)) {
             const params = new URLSearchParams();
@@ -44,6 +45,9 @@ let UndiciHttpClientAdapter = class UndiciHttpClientAdapter extends HttpClientAd
             }
             body = params.toString();
         }
+        else if (isDefined(httpClientRequest.body?.formData)) {
+            body = httpClientRequest.body.formData;
+        }
         try {
             const response = await request(httpClientRequest.url, {
                 method: httpClientRequest.method,

package/http/client/http-client-request.d.ts

@@ -1,5 +1,6 @@
 import { type CancellationSignal } from '../../cancellation/index.js';
 import { dispose, type Disposable } from '../../disposable/index.js';
+import type { OneOrMany } from '../../schema/index.js';
 import type { Record, TypedOmit, UndefinableJson, UndefinableJsonObject } from '../../types.js';
 import { HttpForm, type HttpFormObject } from '../http-form.js';
 import { HttpHeaders, type HttpHeadersObject } from '../http-headers.js';
@@ -11,9 +12,8 @@ export type HttpRequestBody = {
     text?: string;
     json?: UndefinableJson;
     form?: HttpForm;
-    buffer?: Uint8Array;
-    blob?: Blob;
-    stream?: ReadableStream<Uint8Array>;
+    formData?: FormData;
+    binary?: Uint8Array | Blob | ReadableStream<Uint8Array>;
 };
 export type HttpRequestAuthorization = {
     basic?: {
@@ -23,18 +23,17 @@ export type HttpRequestAuthorization = {
     bearer?: string;
     token?: string;
 };
+export type HttpFormDataObjectValue = string | number | boolean | Uint8Array | Blob;
+export type HttpFormDataObject = Record<string, OneOrMany<HttpFormDataObjectValue>>;
 export type HttpClientRequestOptions = Partial<TypedOmit<HttpClientRequest, 'url' | 'method' | 'abortSignal' | 'abort' | 'headers' | 'query' | 'body'>> & {
     urlParameter?: HttpUrlParametersObject | HttpUrlParameters;
     headers?: HttpHeadersObject | HttpHeaders;
     query?: HttpQueryObject | HttpQuery;
     credentials?: HttpRequestCredentials;
     authorization?: HttpRequestAuthorization;
-    body?: {
-        text?: string;
-        json?: UndefinableJson;
+    body?: TypedOmit<HttpRequestBody, 'form' | 'formData'> & {
         form?: HttpFormObject | HttpForm;
-        buffer?: Uint8Array;
-        stream?: ReadableStream<Uint8Array>;
+        formData?: HttpFormDataObject | FormData;
     };
     abortSignal?: CancellationSignal;
 };

package/http/client/http-client-request.js

@@ -1,7 +1,8 @@
 import { CancellationToken } from '../../cancellation/index.js';
 import { dispose } from '../../disposable/index.js';
 import { clone } from '../../utils/clone.js';
-import { isDefined, isString, isUndefined } from '../../utils/type-guards.js';
+import { objectEntries } from '../../utils/object/object.js';
+import { isArray, isBlob, isDefined, isString, isUint8Array, isUndefined } from '../../utils/type-guards.js';
 import { HttpForm } from '../http-form.js';
 import { HttpHeaders } from '../http-headers.js';
 import { HttpQuery } from '../http-query.js';
@@ -149,5 +150,28 @@ function normalizeBody(body) {
     if (isDefined(normalizedBody.form)) {
         normalizedBody.form = new HttpForm(normalizedBody.form);
     }
+    if (isDefined(normalizedBody.formData) && !(normalizedBody.formData instanceof FormData)) {
+        const formData = new FormData();
+        for (const [key, value] of objectEntries(normalizedBody.formData)) {
+            if (isArray(value)) {
+                for (const item of value) {
+                    formData.append(key, convertFormDataObjectValue(item));
+                }
+            }
+            else {
+                formData.set(key, convertFormDataObjectValue(value));
+            }
+        }
+        normalizedBody.formData = formData;
+    }
     return normalizedBody;
 }
+function convertFormDataObjectValue(value) {
+    if (isString(value) || isBlob(value)) {
+        return value;
+    }
+    if (isUint8Array(value)) {
+        return new Blob([value]);
+    }
+    return String(value);
+}

package/http/client/http-client.js

@@ -15,7 +15,7 @@ import { encodeUtf8 } from '../../utils/encoding.js';
 import { composeAsyncMiddleware } from '../../utils/middleware.js';
 import { objectEntries } from '../../utils/object/object.js';
 import { readableStreamFromPromise } from '../../utils/stream/readable-stream-from-promise.js';
-import { assertDefined, isArray, isDefined, isObject, isUndefined } from '../../utils/type-guards.js';
+import { assertDefined, isArray, isBlob, isDefined, isObject, isUndefined } from '../../utils/type-guards.js';
 import { buildUrl } from '../../utils/url-builder.js';
 import { HttpHeaders } from '../http-headers.js';
 import { HttpError, HttpErrorReason } from '../http.error.js';
@@ -217,11 +217,13 @@ function getAddRequestHeadersMiddleware(defaultHeaders) {
             else if (isDefined(body.form)) {
                 request.headers.contentType = 'application/x-www-form-urlencoded';
             }
-            else if (isDefined(body.blob)) {
-                request.headers.contentType = (body.blob.type.length > 0) ? body.blob.type : 'application/octet-stream';
+            else if (isDefined(body.formData)) {
+                // Form data content type header has to be set by implementation because of boundary value
             }
-            else if (isDefined(body.stream) || isDefined(body.buffer)) {
-                request.headers.contentType = 'application/octet-stream';
+            else if (isDefined(body.binary)) {
+                request.headers.contentType = ((isBlob(body.binary) && body.binary.type.length > 0))
+                    ? body.binary.type
+                    : 'application/octet-stream';
             }
         }
         if (isDefined(authorization) && isUndefined(request.headers.authorization)) {

package/memory/observable-finalization-registry.d.ts

@@ -1,4 +1,4 @@
-import type { Observable } from 'rxjs';
+import { type Observable } from 'rxjs';
 export declare class ObservableFinalizationRegistry<T> extends FinalizationRegistry<T> {
     private readonly finalizeSubject;
     readonly finalize$: Observable<T>;

package/orm/entity.d.ts

@@ -0,0 +1,16 @@
+import type { Record, TypedOmit } from '../types.js';
+export declare abstract class EntityMetadata {
+    revision: number;
+    revisionTimestamp: number;
+    createTimestamp: number;
+    deleteTimestamp: number | null;
+    attributes: Record;
+}
+export declare abstract class Entity {
+    id: string;
+    metadata: EntityMetadata;
+}
+export type NewEntity<T extends Entity> = TypedOmit<T, 'id' | 'metadata'> & {
+    id?: string;
+    metadata?: Partial<Pick<EntityMetadata, 'attributes'>>;
+};

package/orm/entity.js

@@ -0,0 +1,49 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { NumberProperty, Property, any, record } from '../schema/index.js';
+export class EntityMetadata {
+    revision;
+    revisionTimestamp;
+    createTimestamp;
+    deleteTimestamp;
+    attributes;
+}
+__decorate([
+    Property(),
+    __metadata("design:type", Number)
+], EntityMetadata.prototype, "revision", void 0);
+__decorate([
+    Property(),
+    __metadata("design:type", Number)
+], EntityMetadata.prototype, "revisionTimestamp", void 0);
+__decorate([
+    Property(),
+    __metadata("design:type", Number)
+], EntityMetadata.prototype, "createTimestamp", void 0);
+__decorate([
+    NumberProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], EntityMetadata.prototype, "deleteTimestamp", void 0);
+__decorate([
+    Property({ schema: record(any(), any()) }),
+    __metadata("design:type", Object)
+], EntityMetadata.prototype, "attributes", void 0);
+export class Entity {
+    id;
+    metadata;
+}
+__decorate([
+    Property(),
+    __metadata("design:type", String)
+], Entity.prototype, "id", void 0);
+__decorate([
+    Property(EntityMetadata),
+    __metadata("design:type", EntityMetadata)
+], Entity.prototype, "metadata", void 0);

package/orm/index.d.ts

@@ -0,0 +1,3 @@
+export * from './entity.js';
+export * from './query.js';
+export * from './repository.js';

package/orm/index.js

@@ -0,0 +1,3 @@
+export * from './entity.js';
+export * from './query.js';
+export * from './repository.js';

package/orm/query.d.ts

@@ -0,0 +1,112 @@
+import type { Flatten, Record } from '../types.js';
+import type { Geometry } from '../types/geo-json.js';
+export type LogicalQuery<T = any> = LogicalAndQuery<T> | LogicalOrQuery<T> | LogicalNorQuery<T>;
+export type LogicalQueryTypes = keyof (LogicalAndQuery & LogicalOrQuery & LogicalNorQuery);
+export declare const allLogicalQueryTypes: LogicalQueryTypes[];
+export type ComparisonQueryBody<T = any> = {
+    [P in keyof T]?: ComparisonQueryOrValue<T[P]>;
+} & Record<ComparisonQueryOrValue>;
+export type ComparisonQueryOrValue<T = any> = ComparisonQuery<T> | T | Flatten<T>;
+export type ComparisonQuery<T = any> = Partial<ComparisonNotQuery<T> & ComparisonEqualsQuery<T> & ComparisonNotEqualsQuery<T> & ComparisonExistsQuery & ComparisonItemQuery<T> & ComparisonInQuery<T> & ComparisonNotInQuery<T> & ComparisonAllQuery<T> & ComparisonGreaterThanQuery<T> & ComparisonGreaterThanOrEqualsQuery<T> & ComparisonLessThanQuery<T> & ComparisonLessThanOrEqualsQuery<T> & ComparisonRegexQuery & ComparisonTextQuery & ComparisonGeoShapeQuery & ComparisonGeoDistanceQuery>;
+export type ComparisonQueryTypes = keyof ComparisonQuery;
+export declare const allComparisonQueryTypes: ComparisonQueryTypes[];
+export type SpecialQuery<T = any> = Partial<TextSpanQuery<T>>;
+export type SpecialQueryTypes = keyof SpecialQuery;
+export declare const allSpecialQueryTypes: SpecialQueryTypes[];
+export type Query<T = any> = LogicalQuery<T> | (ComparisonQueryBody<T> & SpecialQuery<T>);
+export type QueryTypes = LogicalQueryTypes | ComparisonQueryTypes | SpecialQueryTypes;
+export declare const allQueryTypes: ("$and" | "$or" | "$nor" | "$not" | "$eq" | "$neq" | "$exists" | "$item" | "$in" | "$nin" | "$all" | "$gt" | "$gte" | "$lt" | "$lte" | "$regex" | "$text" | "$geoShape" | "$geoDistance" | "$textSpan")[];
+export type Order = 'asc' | 'desc';
+export declare const allOrders: Order[];
+export type Operator = 'and' | 'or';
+export declare const allOperators: Operator[];
+export type LogicalAndQuery<T = any> = {
+    $and: Query<T>[];
+};
+export type LogicalOrQuery<T = any> = {
+    $or: Query<T>[];
+};
+export type LogicalNorQuery<T = any> = {
+    $nor: Query<T>[];
+};
+export type ComparisonValue<T> = T | Flatten<T>;
+export type ComparisonValueWithRegex<T> = T extends string ? ComparisonValue<T | RegExp> : T extends string[] ? ComparisonValue<(Flatten<T> | RegExp)[]> : (T | Flatten<T>);
+export type ComparisonNotQuery<T = any> = {
+    $not: ComparisonQuery<T>;
+};
+export type ComparisonEqualsQuery<T = any> = {
+    $eq: ComparisonValueWithRegex<T>;
+};
+export type ComparisonNotEqualsQuery<T = any> = {
+    $neq: ComparisonValueWithRegex<T>;
+};
+export type ComparisonExistsQuery = {
+    $exists: ComparisonValue<boolean>;
+};
+export type ComparisonItemQuery<T = any> = {
+    $item: T extends (infer U)[] ? U extends Record<any, any> ? Query<U> : ComparisonQuery<U> : never;
+};
+export type ComparisonInQuery<T = any> = {
+    $in: ComparisonValueWithRegex<T>[];
+};
+export type ComparisonNotInQuery<T = any> = {
+    $nin: ComparisonValueWithRegex<T>[];
+};
+export type ComparisonAllQuery<T = any> = {
+    $all: ComparisonValueWithRegex<T>[];
+};
+export type ComparisonGreaterThanQuery<T = any> = {
+    $gt: ComparisonValue<T>;
+};
+export type ComparisonGreaterThanOrEqualsQuery<T = any> = {
+    $gte: ComparisonValue<T>;
+};
+export type ComparisonLessThanQuery<T = any> = {
+    $lt: ComparisonValue<T>;
+};
+export type ComparisonLessThanOrEqualsQuery<T = any> = {
+    $lte: ComparisonValue<T>;
+};
+export type ComparisonRegexQuery = {
+    $regex: string | RegExp | {
+        pattern: string;
+        flags: string;
+    };
+};
+export type ComparisonTextQuery = {
+    $text: string | {
+        text: string;
+        operator?: Operator;
+    };
+};
+export type GeoShapeRelation = 'intersects' | 'within' | 'disjoint' | 'contains';
+export type ComparisonGeoShapeQuery = {
+    $geoShape: {
+        geometry: Geometry;
+        relation: GeoShapeRelation;
+    };
+};
+export type ComparisonGeoDistanceQuery = {
+    $geoDistance: {
+        longitude: number;
+        latitude: number;
+        /**
+         * Maximum distance in meters
+         */
+        maxDistance?: number;
+        /**
+         * Minimum distance in meters
+         */
+        minDistance?: number;
+    };
+};
+export type TextSpanQueryMode = 'best' | 'most' | 'cross';
+export declare const allTextSpanQueryModes: TextSpanQueryMode[];
+export type TextSpanQuery<T = any> = {
+    $textSpan: {
+        fields: (Extract<keyof T, string>)[];
+        text: string;
+        mode?: TextSpanQueryMode;
+        operator?: Operator;
+    };
+};

package/orm/query.js

@@ -0,0 +1,7 @@
+export const allLogicalQueryTypes = ['$and', '$or', '$nor'];
+export const allComparisonQueryTypes = ['$all', '$not', '$eq', '$exists', '$gt', '$gte', '$in', '$item', '$lt', '$lte', '$neq', '$nin', '$regex', '$text', '$geoDistance', '$geoShape'];
+export const allSpecialQueryTypes = ['$textSpan'];
+export const allQueryTypes = [...allLogicalQueryTypes, ...allComparisonQueryTypes, ...allSpecialQueryTypes];
+export const allOrders = ['asc', 'desc'];
+export const allOperators = ['and', 'or'];
+export const allTextSpanQueryModes = ['best', 'most', 'cross'];

package/orm/repository.d.ts

@@ -0,0 +1,50 @@
+import type { Paths, Type, TypedOmit } from '../types.js';
+import type { Entity, EntityMetadata, NewEntity } from './entity.js';
+import type { Query } from './query.js';
+export declare const repositoryType: unique symbol;
+export type OrderOptions<T extends Entity> = {
+    order?: {
+        [P in Paths<T>]?: 1 | -1 | 'asc' | 'desc';
+    };
+};
+export type LoadOptions<T extends Entity> = OrderOptions<T> & {
+    offset?: number;
+};
+export type LoadManyOptions<T extends Entity> = LoadOptions<T> & {
+    limit?: number;
+};
+export type EntityMetadataUpdate = {
+    metadata?: Partial<EntityMetadata>;
+};
+export type EntityUpdate<T extends Entity> = Partial<TypedOmit<T, 'metadata'>> & EntityMetadataUpdate;
+export declare abstract class EntityRepository<T extends Entity = Entity> {
+    readonly type: Type<T>;
+    abstract load(id: string): Promise<T>;
+    abstract tryLoad(id: string): Promise<T | undefined>;
+    abstract loadByFilter(query: Query<T>, options?: LoadOptions<T>): Promise<T>;
+    abstract tryLoadByFilter(query: Query<T>, options?: LoadOptions<T>): Promise<T | undefined>;
+    abstract loadMany(ids: string[], options?: LoadManyOptions<T>): Promise<T[]>;
+    abstract loadManyCursor(ids: string[], options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
+    abstract loadManyByFilter(query: Query<T>, options?: LoadManyOptions<T>): Promise<T[]>;
+    abstract loadManyByFilterCursor(query: Query<T>, options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
+    abstract loadAll(options?: LoadManyOptions<T>): Promise<T[]>;
+    abstract loadAllCursor(options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
+    abstract count(): Promise<number>;
+    abstract countByFilter(query: Query<T>): Promise<number>;
+    abstract has(id: string): Promise<boolean>;
+    abstract hasByFilter(query: Query<T>): Promise<boolean>;
+    abstract hasMany(ids: string[]): Promise<string[]>;
+    abstract hasAll(ids: string[]): Promise<boolean>;
+    abstract insert(entity: NewEntity<T>): Promise<T>;
+    abstract insertMany(entities: NewEntity<T>[]): Promise<T[]>;
+    abstract update(id: string, update: EntityUpdate<T>): Promise<void>;
+    abstract updateByFilter(query: Query<T>, update: EntityUpdate<T>): Promise<void>;
+    abstract updateMany(ids: string[], update: EntityUpdate<T>): Promise<void>;
+    abstract updateManyByFilter(filter: Query<T>, update: EntityUpdate<T>): Promise<void>;
+    abstract delete<U extends T>(entity: U): Promise<boolean>;
+    abstract deleteMany<U extends T>(entities: U[]): Promise<number>;
+    abstract deleteById(id: string): Promise<boolean>;
+    abstract deleteManyById(ids: string[]): Promise<number>;
+    abstract deleteByFilter<U extends T = T>(query: Query<U>): Promise<boolean>;
+    abstract deleteManyByFilter<U extends T = T>(query: Query<U>): Promise<number>;
+}

package/orm/repository.js

@@ -0,0 +1,4 @@
+export const repositoryType = Symbol('repositoryType');
+export class EntityRepository {
+    type;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.85",
+  "version": "0.90.89",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -115,7 +115,7 @@
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
-    "@stylistic/eslint-plugin": "2.1",
+    "@stylistic/eslint-plugin": "2.2",
     "@types/chroma-js": "2.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.4",
@@ -134,7 +134,7 @@
     "typescript": "5.4"
   },
   "peerDependencies": {
-    "@elastic/elasticsearch": "^8.13",
+    "@elastic/elasticsearch": "^8.14",
     "@koa/router": "^12.0",
     "@tstdl/angular": "^0.90",
     "@zxcvbn-ts/core": "^3.0",

package/schema/schemas/record.d.ts

@@ -1,5 +1,5 @@
 import type { OneOrMany, Record, TypedOmit } from '../../types.js';
 import type { SchemaTestable } from '../schema.js';
-import type { ObjectSchema } from '../types/index.js';
+import { type ObjectSchema } from '../types/index.js';
 export type RecordOptions<T extends Record = Record> = TypedOmit<ObjectSchema<T>, 'properties' | 'unknownProperties' | 'unknownPropertiesKey' | 'mask'>;
 export declare function record<K extends PropertyKey, T>(keySchema: OneOrMany<SchemaTestable<K>>, valueSchema: OneOrMany<SchemaTestable<T>>, options?: RecordOptions): ObjectSchema<Record<K, T>>;

package/utils/async-iterable-helpers/group-to-map.js

@@ -1,4 +1,3 @@
-import { FactoryMap } from '../factory-map.js';
 import { isAsyncIterable } from './is-async-iterable.js';
 export async function groupToMapAsync(iterable, selector) {
     return isAsyncIterable(iterable)
@@ -6,20 +5,26 @@ export async function groupToMapAsync(iterable, selector) {
         : sync(iterable, selector);
 }
 async function async(iterable, selector) {
-    const map = new FactoryMap(() => []);
+    const map = new Map();
     let index = 0;
     for await (const item of iterable) {
         const groupKey = await selector(item, index++);
+        if (!map.has(groupKey)) {
+            map.set(groupKey, []);
+        }
         map.get(groupKey).push(item);
     }
-    return map.backingMap;
+    return map;
 }
 async function sync(iterable, selector) {
-    const map = new FactoryMap(() => []);
+    const map = new Map();
     let index = 0;
     for (const item of iterable) {
         const groupKey = await selector(item, index++);
+        if (!map.has(groupKey)) {
+            map.set(groupKey, []);
+        }
         map.get(groupKey).push(item);
     }
-    return map.backingMap;
+    return map;
 }

package/utils/async-iterable-helpers/parallel/group.js

@@ -1,10 +1,12 @@
-import { FactoryMap } from '../../factory-map.js';
 import { parallelForEach } from './for-each.js';
 export async function parallelGroup(iterable, concurrency, selector) {
-    const map = new FactoryMap(() => []);
+    const map = new Map();
     await parallelForEach(iterable, concurrency, async (item, index) => {
         const groupKey = await selector(item, index);
+        if (!map.has(groupKey)) {
+            map.set(groupKey, []);
+        }
         map.get(groupKey).push(item);
     });
-    return map.backingMap;
+    return map;
 }

package/utils/factory-map.d.ts

@@ -1,10 +1,16 @@
 export type Factory<Key, Value> = (key: Key) => Value;
-/** same as {@link Map}, except that it will build the value with the provided factory on {@link get} if it doesnt exist */
-export declare class FactoryMap<K, V> implements Map<K, V> {
+export type FactoryItemIdentityProvider<K, I> = (key: K) => I;
+/** Same as {@link Map}, except that it will build the value with the provided factory on {@link get} if it doesnt exist */
+export declare class FactoryMap<K, V, I = K> implements Map<K, V> {
     private readonly factory;
     readonly [Symbol.toStringTag]: 'FactoryMap';
-    readonly backingMap: Map<K, V>;
+    readonly backingMap: Map<I, {
+        key: K;
+        value: V;
+    }>;
+    readonly identityProvider: FactoryItemIdentityProvider<K, I>;
     get size(): number;
+    constructor(factory: Factory<K, V>, backingMap: Map<I, V> | undefined, identityProvider: FactoryItemIdentityProvider<K, I>);
     constructor(factory: Factory<K, V>, backingMap?: Map<K, V>);
     clear(): void;
     has(key: K): boolean;
@@ -12,7 +18,7 @@ export declare class FactoryMap<K, V> implements Map<K, V> {
     getWithoutBuild(key: K): V | undefined;
     set(key: K, value: V): this;
     delete(key: K): boolean;
-    forEach(callback: (value: V, key: K, map: FactoryMap<K, V>) => void, thisArg?: any): void;
+    forEach(callback: (value: V, key: K, map: FactoryMap<K, V, I>) => void, thisArg?: any): void;
     [Symbol.iterator](): IterableIterator<[K, V]>;
     entries(): IterableIterator<[K, V]>;
     keys(): IterableIterator<K>;

package/utils/factory-map.js

@@ -1,55 +1,66 @@
-/** same as {@link Map}, except that it will build the value with the provided factory on {@link get} if it doesnt exist */
+/** Same as {@link Map}, except that it will build the value with the provided factory on {@link get} if it doesnt exist */
 export class FactoryMap {
     factory;
     [Symbol.toStringTag];
     backingMap;
+    identityProvider;
     get size() {
         return this.backingMap.size;
     }
-    constructor(factory, backingMap) {
+    constructor(factory, backingMap, identityProvider) {
         this.factory = factory;
         this[Symbol.toStringTag] = 'FactoryMap';
         this.backingMap = backingMap ?? new Map();
+        this.identityProvider = identityProvider ?? ((key) => key);
     }
     clear() {
         this.backingMap.clear();
     }
     has(key) {
-        return this.backingMap.has(key);
+        return this.backingMap.has(this.identityProvider(key));
     }
     get(key) {
-        const has = this.backingMap.has(key);
+        const identity = this.identityProvider(key);
+        const has = this.backingMap.has(identity);
         if (has) {
-            return this.backingMap.get(key);
+            return this.backingMap.get(identity).value;
         }
         const value = this.factory(key);
-        this.backingMap.set(key, value);
+        this.backingMap.set(identity, { key, value });
         return value;
     }
     getWithoutBuild(key) {
-        return this.backingMap.get(key);
+        return this.backingMap.get(this.identityProvider(key))?.value;
     }
     set(key, value) {
-        this.backingMap.set(key, value);
+        this.backingMap.set(this.identityProvider(key), { key, value });
         return this;
     }
     delete(key) {
-        return this.backingMap.delete(key);
+        return this.backingMap.delete(this.identityProvider(key));
     }
     forEach(callback, thisArg) {
         const boundCallback = callback.bind(thisArg);
-        this.backingMap.forEach((value, key) => boundCallback(value, key, this));
+        this.backingMap.forEach(({ key, value }) => boundCallback(value, key, this));
     }
     *[Symbol.iterator]() {
-        yield* this.backingMap[Symbol.iterator]();
+        for (const [, { key, value }] of this.backingMap) {
+            yield [key, value];
+        }
     }
     *entries() {
-        yield* this.backingMap.entries();
+        for (const [, { key, value }] of this.backingMap.entries()) {
+            yield [key, value];
+        }
     }
     *keys() {
-        yield* this.backingMap.keys();
+        for (const [, { key }] of this.backingMap.entries()) {
+            yield key;
+        }
     }
     *values() {
-        yield* this.backingMap.values();
+        for (const [, { value }] of this.backingMap.entries()) {
+            yield value;
+        }
     }
 }

package/utils/iterable-helpers/group-to-map.js

@@ -1,10 +1,12 @@
-import { FactoryMap } from '../factory-map.js';
 export function groupToMap(iterable, selector) {
-    const map = new FactoryMap(() => []);
+    const map = new Map();
     let index = 0;
     for (const item of iterable) {
         const groupKey = selector(item, index++);
+        if (!map.has(groupKey)) {
+            map.set(groupKey, []);
+        }
         map.get(groupKey).push(item);
     }
-    return map.backingMap;
+    return map;
 }