@tstdl/base 0.90.89 → 0.90.91

package/api/client/client.js

@@ -2,7 +2,6 @@ import { HttpClient, HttpClientRequest } from '../../http/client/index.js';
 import { normalizeSingleHttpValue } from '../../http/types.js';
 import { inject } from '../../injector/inject.js';
 import { Injector } from '../../injector/injector.js';
-import { resolveArgumentType } from '../../injector/interfaces.js';
 import { Schema } from '../../schema/index.js';
 import { ServerSentEvents } from '../../sse/server-sent-events.js';
 import { toArray } from '../../utils/array/array.js';

package/api/server/gateway.js

@@ -15,7 +15,7 @@ import { BadRequestError } from '../../errors/bad-request.error.js';
 import { NotFoundError } from '../../errors/not-found.error.js';
 import { NotImplementedError } from '../../errors/not-implemented.error.js';
 import { HttpServerResponse } from '../../http/server/index.js';
-import { InjectArg, ResolveArg, Singleton, resolveArgumentType } from '../../injector/index.js';
+import { InjectArg, ResolveArg, Singleton } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { Schema } from '../../schema/index.js';
 import { ServerSentEventsSource } from '../../sse/server-sent-events-source.js';

package/application/application.js

@@ -9,7 +9,6 @@ import { getGlobalInjector } from '../core.js';
 import { Singleton } from '../injector/decorators.js';
 import { inject, injectArgument, runInInjectionContext } from '../injector/inject.js';
 import { Injector } from '../injector/injector.js';
-import { resolveArgumentType } from '../injector/interfaces.js';
 import { Logger } from '../logger/index.js';
 import { ModuleBase } from '../module/module-base.js';
 import { ModuleState } from '../module/module.js';

package/authentication/authentication.api.d.ts

@@ -77,7 +77,7 @@ export declare const authenticationApiDefinition: {
             method: "POST";
             parameters: ObjectSchema<{
                 subject: string;
-                data: {};
+                data: import("../types.js").ObjectLiteral;
             }>;
             result: import("../schema/types/types.js").ValueSchema<"ok">;
         };

package/authentication/client/api.client.d.ts

@@ -4,7 +4,7 @@ import type { ObjectSchemaOrType } from '../../schema/types/types.js';
 import type { Record } from '../../types.js';
 import type { AuthenticationApiDefinition } from '../authentication.api.js';
 export declare function getAuthenticationApiClient<AdditionalTokenPayload extends Record, AuthenticationData, AdditionalInitSecretResetData extends Record>(additionalTokenPayloadSchema: ObjectSchemaOrType<AdditionalTokenPayload>, authenticationDataSchema: SchemaTestable<AuthenticationData>, additionalInitSecretResetData: ObjectSchemaOrType<AdditionalInitSecretResetData>): ApiClient<AuthenticationApiDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>>;
-declare const defaultAuthenticationApiClient: ApiClient<AuthenticationApiDefinition<{}, unknown, {}>>;
+declare const defaultAuthenticationApiClient: ApiClient<AuthenticationApiDefinition<import("../../types.js").ObjectLiteral, unknown, import("../../types.js").ObjectLiteral>>;
 export declare class AuthenticationApiClient extends defaultAuthenticationApiClient {
 }
 export {};

package/authentication/server/mongo/mongo-authentication-credentials.repository.js

@@ -12,7 +12,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { getNewId } from '../../../database/index.js';
 import { Collection, MongoEntityRepository, noopTransformer } from '../../../database/mongo/index.js';
-import { ForwardArg, Singleton, resolveArgumentType } from '../../../injector/index.js';
+import { ForwardArg, Singleton } from '../../../injector/index.js';
 import { Logger } from '../../../logger/index.js';
 import { isUndefined } from '../../../utils/type-guards.js';
 import { AuthenticationCredentialsRepository } from '../authentication-credentials.repository.js';

package/authentication/server/mongo/mongo-authentication-session.repository.js

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Collection, MongoEntityRepository, noopTransformer } from '../../../database/mongo/index.js';
-import { ForwardArg, Singleton, resolveArgumentType } from '../../../injector/index.js';
+import { ForwardArg, Singleton } from '../../../injector/index.js';
 import { Logger } from '../../../logger/index.js';
 import { AuthenticationSessionRepository } from '../authentication-session.repository.js';
 let defaultArgument;

package/browser/browser-context-controller.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { disposeAsync } from '../disposable/disposable.js';
 import { Injectable } from '../injector/decorators.js';
-import { afterResolve, resolveArgumentType } from '../injector/interfaces.js';
+import { afterResolve } from '../injector/interfaces.js';
 import { filterUndefinedFromRecord } from '../utils/object/object.js';
 import { isDefined } from '../utils/type-guards.js';
 import { BrowserController } from './browser-controller.js';

package/browser/browser-controller.js

@@ -10,7 +10,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { disposeAsync } from '../disposable/disposable.js';
 import { Injectable } from '../injector/decorators.js';
 import { inject } from '../injector/inject.js';
-import { resolveArgumentType } from '../injector/interfaces.js';
 import { filterUndefinedFromRecord } from '../utils/object/object.js';
 import { isDefined } from '../utils/type-guards.js';
 import { BrowserContextController } from './browser-context-controller.js';

package/browser/browser.service.js

@@ -12,7 +12,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { disposeAsync } from '../disposable/disposable.js';
 import { InjectArg, Singleton } from '../injector/decorators.js';
-import { resolveArgumentType } from '../injector/interfaces.js';
 import { filterUndefinedFromRecord } from '../utils/object/object.js';
 import { isDefined } from '../utils/type-guards.js';
 import { BrowserContextController } from './browser-context-controller.js';

package/collections/awaitable/awaitable-set.d.ts

@@ -12,6 +12,13 @@ export declare class AwaitableSet<T> implements Set<T> {
     add(value: T): this;
     clear(): void;
     delete(value: T): boolean;
+    union<U>(other: ReadonlySetLike<U>): Set<T | U>;
+    intersection<U>(other: ReadonlySetLike<U>): Set<T & U>;
+    difference<U>(other: ReadonlySetLike<U>): Set<T>;
+    symmetricDifference<U>(other: ReadonlySetLike<U>): Set<T | U>;
+    isSubsetOf(other: ReadonlySetLike<unknown>): boolean;
+    isSupersetOf(other: ReadonlySetLike<unknown>): boolean;
+    isDisjointFrom(other: ReadonlySetLike<unknown>): boolean;
     forEach(callback: (value: T, value2: T, set: AwaitableSet<T>) => void, thisArg?: any): void;
     has(value: T): boolean;
     entries(): IterableIterator<[T, T]>;

package/collections/awaitable/awaitable-set.js

@@ -43,6 +43,27 @@ export class AwaitableSet {
         }
         return success;
     }
+    union(other) {
+        return this.backingSet.union(other);
+    }
+    intersection(other) {
+        return this.backingSet.intersection(other);
+    }
+    difference(other) {
+        return this.backingSet.difference(other);
+    }
+    symmetricDifference(other) {
+        return this.backingSet.symmetricDifference(other);
+    }
+    isSubsetOf(other) {
+        return this.backingSet.isSubsetOf(other);
+    }
+    isSupersetOf(other) {
+        return this.backingSet.isSupersetOf(other);
+    }
+    isDisjointFrom(other) {
+        return this.backingSet.isDisjointFrom(other);
+    }
     forEach(callback, thisArg) {
         const boundCallback = callback.bind(thisArg);
         this.backingSet.forEach((value, value2) => boundCallback(value, value2, this));

package/collections/keyed-set.d.ts

@@ -13,6 +13,13 @@ export declare class KeyedSet<T> implements Set<T> {
     add(value: T): this;
     clear(): void;
     delete(value: T): boolean;
+    union<U>(_other: ReadonlySetLike<U>): Set<T | U>;
+    intersection<U>(_other: ReadonlySetLike<U>): Set<T & U>;
+    difference<U>(_other: ReadonlySetLike<U>): Set<T>;
+    symmetricDifference<U>(_other: ReadonlySetLike<U>): Set<T | U>;
+    isSubsetOf(_other: ReadonlySetLike<unknown>): boolean;
+    isSupersetOf(_other: ReadonlySetLike<unknown>): boolean;
+    isDisjointFrom(_other: ReadonlySetLike<unknown>): boolean;
     forEach(callback: (value: T, value2: T, set: KeyedSet<T>) => void, thisArg?: any): void;
     has(value: T): boolean;
     [Symbol.iterator](): IterableIterator<T>;

package/collections/keyed-set.js

@@ -1,3 +1,4 @@
+import { NotSupportedError } from '../errors/not-supported.error.js';
 import { map } from '../utils/iterable-helpers/map.js';
 export var KeyedSetMode;
 (function (KeyedSetMode) {
@@ -33,6 +34,27 @@ export class KeyedSet {
         const key = this.selector(value);
         return this.backingMap.delete(key);
     }
+    union(_other) {
+        throw new NotSupportedError();
+    }
+    intersection(_other) {
+        throw new NotSupportedError();
+    }
+    difference(_other) {
+        throw new NotSupportedError();
+    }
+    symmetricDifference(_other) {
+        throw new NotSupportedError();
+    }
+    isSubsetOf(_other) {
+        throw new NotSupportedError();
+    }
+    isSupersetOf(_other) {
+        throw new NotSupportedError();
+    }
+    isDisjointFrom(_other) {
+        throw new NotSupportedError();
+    }
     forEach(callback, thisArg) {
         const boundCallback = callback.bind(thisArg);
         this.backingMap.forEach((value) => boundCallback(value, value, this));

package/collections/observable/observable-set.d.ts

@@ -1,9 +1,9 @@
-import type { ObservableCollection } from './observable-collection.js';
 import { ObservableCollectionBase } from './observable-collection-base.js';
+import type { ObservableCollection } from './observable-collection.js';
 export declare class ObservableSet<T> extends ObservableCollectionBase<T, ObservableSet<T>> implements Set<T>, ObservableCollection<T> {
     private readonly backingSet;
     readonly [Symbol.toStringTag]: 'ObservableSet';
-    get self(): ObservableSet<T>;
+    get self(): this;
     get length(): number;
     get size(): number;
     constructor(values?: Iterable<T> | null);
@@ -13,6 +13,13 @@ export declare class ObservableSet<T> extends ObservableCollectionBase<T, Observ
     remove(value: T): boolean;
     removeMany(values: T[]): number;
     delete(value: T): boolean;
+    union<U>(other: ReadonlySetLike<U>): Set<T | U>;
+    intersection<U>(other: ReadonlySetLike<U>): Set<T & U>;
+    difference<U>(other: ReadonlySetLike<U>): Set<T>;
+    symmetricDifference<U>(other: ReadonlySetLike<U>): Set<T | U>;
+    isSubsetOf(other: ReadonlySetLike<unknown>): boolean;
+    isSupersetOf(other: ReadonlySetLike<unknown>): boolean;
+    isDisjointFrom(other: ReadonlySetLike<unknown>): boolean;
     forEach(callback: (value: T, value2: T, set: ObservableSet<T>) => void, thisArg?: any): void;
     has(value: T): boolean;
     entries(): IterableIterator<[T, T]>;

package/collections/observable/observable-set.js

@@ -54,6 +54,27 @@ export class ObservableSet extends ObservableCollectionBase {
     delete(value) {
         return this.remove(value);
     }
+    union(other) {
+        return this.backingSet.union(other);
+    }
+    intersection(other) {
+        return this.backingSet.intersection(other);
+    }
+    difference(other) {
+        return this.backingSet.difference(other);
+    }
+    symmetricDifference(other) {
+        return this.backingSet.symmetricDifference(other);
+    }
+    isSubsetOf(other) {
+        return this.backingSet.isSubsetOf(other);
+    }
+    isSupersetOf(other) {
+        return this.backingSet.isSupersetOf(other);
+    }
+    isDisjointFrom(other) {
+        return this.backingSet.isDisjointFrom(other);
+    }
     forEach(callback, thisArg) {
         const boundCallback = callback.bind(thisArg);
         this.backingSet.forEach((value, value2) => boundCallback(value, value2, this));

package/context/context.d.ts

@@ -1,29 +1,18 @@
+import type { SimplifyObject } from '../types.js';
 /**
  * Creates a new context provider
  * @param name name of of the context used for function names
  */
-export declare function createContextProvider<Context, const Name extends string>(name: Name): { [P in `getCurrent${Name}Context`]: {
+export declare function createContextProvider<Context, const Name extends string>(name: Name): SimplifyObject<{ [P in `getCurrent${Name}Context`]: {
     (required: true, debugFn: Function): Context;
     (required?: false | undefined, debugFn?: Function): Context | null;
     (required: boolean, debugFn: Function): Context | null;
-}; } & { [P_1 in `setCurrent${Name}Context`]: (context: Context | null) => Context | null; } & { [P_2 in `runIn${Name}Context`]: <ReturnT>(context: Context, fn: () => ReturnT) => ReturnT; } & { [P_3 in `isIn${Name}Context`]: {
+}; } & { [P in `setCurrent${Name}Context`]: (context: Context | null) => Context | null; } & { [P in `runIn${Name}Context`]: <ReturnT>(context: Context, fn: () => ReturnT) => ReturnT; } & { [P in `isIn${Name}Context`]: {
     (required: true, debugFn: Function): Context;
     (required?: false | undefined, debugFn?: Function): Context | null;
     (required: boolean, debugFn: Function): Context | null;
-}; } & { [P_4 in `assertIn${Name}Context`]: {
+}; } & { [P in `assertIn${Name}Context`]: {
     (required: true, debugFn: Function): Context;
     (required?: false | undefined, debugFn?: Function): Context | null;
     (required: boolean, debugFn: Function): Context | null;
-}; } extends infer T extends import("../types.js").Record<PropertyKey, any> ? { [K in keyof T]: ({ [P in `getCurrent${Name}Context`]: {
-    (required: true, debugFn: Function): Context;
-    (required?: false | undefined, debugFn?: Function): Context | null;
-    (required: boolean, debugFn: Function): Context | null;
-}; } & { [P_1 in `setCurrent${Name}Context`]: (context: Context | null) => Context | null; } & { [P_2 in `runIn${Name}Context`]: <ReturnT>(context: Context, fn: () => ReturnT) => ReturnT; } & { [P_3 in `isIn${Name}Context`]: {
-    (required: true, debugFn: Function): Context;
-    (required?: false | undefined, debugFn?: Function): Context | null;
-    (required: boolean, debugFn: Function): Context | null;
-}; } & { [P_4 in `assertIn${Name}Context`]: {
-    (required: true, debugFn: Function): Context;
-    (required?: false | undefined, debugFn?: Function): Context | null;
-    (required: boolean, debugFn: Function): Context | null;
-}; })[K]; } : never;
+}; }>;

package/data-structures/distinct-collection.d.ts

@@ -1,20 +1,29 @@
 import { Collection } from './collection.js';
 export declare abstract class DistinctCollection<T, TThis extends DistinctCollection<T, TThis> = DistinctCollection<T, any>> extends Collection<T, TThis> {
-    /** Creates a new map and copies the items */
+    /** Creates a new set and copies the items */
     toSet(): Set<T>;
     /** Returns an adapter that has the same interface as {@link Set}. No copying of data involved. */
     asSet(): Set<T>;
     abstract has(value: T): boolean;
     abstract delete(value: T): boolean;
+    protected abstract _getBackingSet(): ReadonlySet<T> | undefined;
 }
 export declare class SetAdapter<T> implements Set<T> {
     private readonly collection;
     readonly [Symbol.toStringTag] = "SetAdapter";
+    private get fastestBackingSet();
     get size(): number;
     constructor(set: DistinctCollection<T, any>);
     add(value: T): this;
     clear(): void;
     delete(value: T): boolean;
+    union<U>(other: ReadonlySetLike<U>): Set<T | U>;
+    intersection<U>(other: ReadonlySetLike<U>): Set<T & U>;
+    difference<U>(other: ReadonlySetLike<U>): Set<T>;
+    symmetricDifference<U>(other: ReadonlySetLike<U>): Set<T | U>;
+    isSubsetOf(other: ReadonlySetLike<unknown>): boolean;
+    isSupersetOf(other: ReadonlySetLike<unknown>): boolean;
+    isDisjointFrom(other: ReadonlySetLike<unknown>): boolean;
     forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
     has(value: T): boolean;
     entries(): IterableIterator<[T, T]>;

package/data-structures/distinct-collection.js

@@ -1,6 +1,7 @@
 import { Collection } from './collection.js';
+;
 export class DistinctCollection extends Collection {
-    /** Creates a new map and copies the items */
+    /** Creates a new set and copies the items */
     toSet() {
         return new Set(this);
     }
@@ -12,6 +13,9 @@ export class DistinctCollection extends Collection {
 export class SetAdapter {
     collection;
     [Symbol.toStringTag] = 'SetAdapter';
+    get fastestBackingSet() {
+        return this.collection._backingSet ?? this.collection.toSet();
+    }
     get size() {
         return this.collection.size;
     }
@@ -28,6 +32,27 @@ export class SetAdapter {
     delete(value) {
         return this.collection.delete(value);
     }
+    union(other) {
+        return this.fastestBackingSet.union(other);
+    }
+    intersection(other) {
+        return this.fastestBackingSet.intersection(other);
+    }
+    difference(other) {
+        return this.fastestBackingSet.difference(other);
+    }
+    symmetricDifference(other) {
+        return this.fastestBackingSet.symmetricDifference(other);
+    }
+    isSubsetOf(other) {
+        return this.fastestBackingSet.isSubsetOf(other);
+    }
+    isSupersetOf(other) {
+        return this.fastestBackingSet.isSupersetOf(other);
+    }
+    isDisjointFrom(other) {
+        return this.fastestBackingSet.isDisjointFrom(other);
+    }
     forEach(callbackfn, thisArg) {
         for (const value of this.collection) {
             callbackfn.call(thisArg, value, value, this);

package/data-structures/multi-key-set.d.ts

@@ -1,5 +1,5 @@
 import { DistinctCollection } from './distinct-collection.js';
-import { NewMapProvider } from './multi-key-map.js';
+import { type NewMapProvider } from './multi-key-map.js';
 export declare class MultiKeySet<T extends any[]> extends DistinctCollection<T> {
     #private;
     readonly [Symbol.toStringTag]: string;
@@ -15,5 +15,6 @@ export declare class MultiKeySet<T extends any[]> extends DistinctCollection<T>
     clone(): MultiKeySet<T>;
     items(): IterableIterator<T>;
     protected _clear(): void;
+    protected _getBackingSet(): ReadonlySet<T> | undefined;
     private updateSize;
 }

package/data-structures/multi-key-set.js

@@ -52,6 +52,9 @@ export class MultiKeySet extends DistinctCollection {
         this.#map.clear();
         this.updateSize();
     }
+    _getBackingSet() {
+        return undefined;
+    }
     updateSize() {
         this.setSize(this.#map.size);
     }

package/data-structures/set-collection.d.ts

@@ -3,17 +3,26 @@ export declare class SetCollection<T> extends DistinctCollection<T, SetCollectio
     private readonly backingSet;
     readonly [Symbol.toStringTag]: string;
     constructor(items?: Iterable<T>);
+    private static withBackingSet;
     includes(item: T): boolean;
     add(item: T): this;
     addMany(items: Iterable<T>): void;
     clone(): SetCollection<T>;
     items(): IterableIterator<T>;
     delete(item: T): boolean;
+    union<U>(other: ReadonlySetLike<U>): SetCollection<T | U>;
+    intersection<U>(other: ReadonlySetLike<U>): SetCollection<T & U>;
+    difference<U>(other: ReadonlySetLike<U>): SetCollection<T>;
+    symmetricDifference<U>(other: ReadonlySetLike<U>): SetCollection<T | U>;
+    isSubsetOf(other: ReadonlySetLike<unknown>): boolean;
+    isSupersetOf(other: ReadonlySetLike<unknown>): boolean;
+    isDisjointFrom(other: ReadonlySetLike<unknown>): boolean;
     forEach(callbackfn: (value: T, value2: T, set: globalThis.Set<T>) => void, thisArg?: any): void;
     has(item: T): boolean;
     entries(): IterableIterator<[T, T]>;
     keys(): IterableIterator<T>;
     values(): IterableIterator<T>;
     protected _clear(): void;
+    protected _getBackingSet(): ReadonlySet<T> | undefined;
     private updateSize;
 }

package/data-structures/set-collection.js

@@ -7,6 +7,11 @@ export class SetCollection extends DistinctCollection {
         this.backingSet = new globalThis.Set(items);
         this.updateSize();
     }
+    static withBackingSet(set) {
+        const collection = new SetCollection();
+        collection.backingSet = set;
+        return collection;
+    }
     includes(item) {
         return this.has(item);
     }
@@ -32,6 +37,27 @@ export class SetCollection extends DistinctCollection {
         this.updateSize();
         return result;
     }
+    union(other) {
+        return SetCollection.withBackingSet(this.backingSet.union(other));
+    }
+    intersection(other) {
+        return SetCollection.withBackingSet(this.backingSet.intersection(other));
+    }
+    difference(other) {
+        return SetCollection.withBackingSet(this.backingSet.difference(other));
+    }
+    symmetricDifference(other) {
+        return SetCollection.withBackingSet(this.backingSet.symmetricDifference(other));
+    }
+    isSubsetOf(other) {
+        return this.backingSet.isSubsetOf(other);
+    }
+    isSupersetOf(other) {
+        return this.backingSet.isSupersetOf(other);
+    }
+    isDisjointFrom(other) {
+        return this.backingSet.isDisjointFrom(other);
+    }
     forEach(callbackfn, thisArg) {
         this.backingSet.forEach(callbackfn, thisArg);
     }
@@ -50,6 +76,9 @@ export class SetCollection extends DistinctCollection {
     _clear() {
         this.backingSet.clear();
     }
+    _getBackingSet() {
+        return this.backingSet;
+    }
     updateSize() {
         this.setSize(this.backingSet.size);
     }

package/database/mongo/classes.js

@@ -4,8 +4,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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;
 };
-/* eslint-disable max-classes-per-file */
-import { resolveArgumentType } from '../../injector/interfaces.js';
 import { ReplaceClass } from '../../injector/decorators.js';
 import { Db, Collection as MongoCollection, MongoClient as MongoMongoClient } from 'mongodb';
 let MongoClient = class MongoClient extends MongoMongoClient {

package/database/mongo/mongo-entity-repository.js

@@ -1,7 +1,7 @@
 import { EntityRepository } from '../../database/index.js';
 import { afterResolve } from '../../injector/index.js';
 import { equals } from '../../utils/equals.js';
-import { filterUndefinedFromRecord, objectEntries, objectKeys } from '../../utils/object/object.js';
+import { filterUndefinedObjectProperties, objectEntries, objectKeys } from '../../utils/object/object.js';
 import { _throw } from '../../utils/throw.js';
 import { isDefined, isUndefined } from '../../utils/type-guards.js';
 import { MongoBaseRepository } from './mongo-base.repository.js';
@@ -263,7 +263,7 @@ export class MongoEntityRepository extends EntityRepository {
 function normalizeIndex(index) {
     const { name: providedName, unique, v, background, ns, ...indexRest } = index; // eslint-disable-line @typescript-eslint/no-unused-vars
     const name = providedName ?? objectKeys(index.key).join('_');
-    return filterUndefinedFromRecord({ name, unique: (unique == true) ? true : undefined, ...indexRest });
+    return filterUndefinedObjectProperties({ name, unique: (unique == true) ? true : undefined, ...indexRest });
 }
 function convertOptions(options, mappingMap) {
     if (options == undefined) {

package/distributed-loop/distributed-loop.js

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { CancellationToken } from '../cancellation/index.js';
-import { InjectArg, Injectable, resolveArgumentType } from '../injector/index.js';
+import { InjectArg, Injectable } from '../injector/index.js';
 import { LockProvider } from '../lock/index.js';
 import { DeferredPromise } from '../promise/deferred-promise.js';
 import { Timer } from '../utils/timer.js';

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

@@ -1,4 +1,4 @@
-import { type Signal } from '../../signals/api.js';
 import { type Observable } from 'rxjs';
+import { type Signal } from '../../signals/api.js';
 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,25 +1,38 @@
-import { IterableWeakMap } from '../../data-structures/iterable-weak-map.js';
+import { Subject, filter, fromEventPattern, map, shareReplay, startWith } from 'rxjs';
 import { toSignal } from '../../signals/api.js';
 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);
-            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())
+const nullRoot = { nullRoot: true };
+const rootMap = new FactoryMap((root) => {
+    const rootMarginMap = new FactoryMap((rootMargin) => {
+        const thresholdMap = new FactoryMap((threshold) => {
+            const observer = new IntersectionObserver((entries) => subject.next(entries), { root: root == nullRoot ? null : root, rootMargin, threshold });
+            const subject = new Subject();
+            const elementObservablesMap = new FactoryMap((element) => fromEventPattern((handler) => {
+                observer.observe(element);
+                return subject.pipe(startWith(observer.takeRecords()), map((entries) => entries.find((entry) => entry.target == element)), filter(isDefined)).subscribe((entry) => handler(entry));
+            }, (_, subscription) => {
+                observer.unobserve(element);
+                subscription.unsubscribe();
+                elementObservablesMap.delete(element);
+                if (elementObservablesMap.size == 0) {
+                    thresholdMap.delete(threshold);
+                    if (thresholdMap.size == 0) {
+                        rootMarginMap.delete(rootMargin);
+                        if (rootMarginMap.size == 0) {
+                            rootMap.delete(root);
+                        }
+                    }
+                }
+            }).pipe(shareReplay({ bufferSize: 1, refCount: true })));
+            return elementObservablesMap;
+        }, undefined, (threshold) => isNumber(threshold) ? threshold : threshold?.join(','));
+        return thresholdMap;
     });
-}, undefined, (threshold) => isNumber(threshold) ? threshold : threshold?.join(','))));
+    return rootMarginMap;
+});
 export function observeIntersection$(element, options) {
-    return observerMap.get(options?.root).get(options?.rootMargin).get(options?.threshold).elementObservables.get(element);
+    return rootMap.get(options?.root ?? nullRoot).get(options?.rootMargin).get(options?.threshold).get(element);
 }
 export function observeIntersection(elements, options) {
     return toSignal(observeIntersection$(elements, options));

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

@@ -8,7 +8,7 @@ import { Readable } from 'node:stream';
 import { request, errors as undiciErrors } from 'undici';
 import { HttpHeaders } from '../../../http/http-headers.js';
 import { HttpError, HttpErrorReason } from '../../../http/http.error.js';
-import { Singleton, injectArgument, resolveArgumentType } from '../../../injector/index.js';
+import { Singleton, injectArgument } from '../../../injector/index.js';
 import { Injector } from '../../../injector/injector.js';
 import { toArray } from '../../../utils/array/array.js';
 import { isBlob, isDefined, isUint8Array } from '../../../utils/type-guards.js';

package/http/client/http-client.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { hasErrorHandler, isErrorResponse, parseErrorResponse } from '../../api/response.js';
-import { Singleton, inject, injectAll, injectArgument, resolveArgumentType } from '../../injector/index.js';
+import { Singleton, inject, injectAll, injectArgument } from '../../injector/index.js';
 import { toArray } from '../../utils/array/array.js';
 import { encodeBase64 } from '../../utils/base64.js';
 import { encodeUtf8 } from '../../utils/encoding.js';

package/http/server/node/node-http-server.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import * as Http from 'node:http';
 import { disposeAsync, type AsyncDisposable } from '../../../disposable/index.js';
 import { Logger } from '../../../logger/index.js';

package/image-service/imgproxy/imgproxy-image-service.js

@@ -10,7 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { InjectArg, Singleton, injectionToken, resolveArgumentType } from '../../injector/index.js';
+import { InjectArg, Singleton, injectionToken } from '../../injector/index.js';
 import { Injector } from '../../injector/injector.js';
 import { encodeBase64Url } from '../../utils/base64.js';
 import { concatArrayBufferViews } from '../../utils/binary.js';

package/import.js

@@ -1,3 +1,3 @@
 export async function dynamicImport(id) {
-    return import(id);
+    return import(/* @vite-ignore */ id);
 }

package/intl/number-parser.d.ts

@@ -14,5 +14,5 @@ export declare class NumberParser {
      */
     parse(value: string, loose?: boolean): number;
 }
-export declare const getNumberParser: (locale: string) => NumberParser;
+export declare const getNumberParser: (locale: string) => InstanceType<typeof NumberParser>;
 export declare function parseNumber(locale: string, value: string, loose?: boolean): number;

package/key-value-store/key-value.store.js

@@ -1,4 +1,3 @@
-import { resolveArgumentType } from '../injector/interfaces.js';
 export class KeyValueStore {
     module;
     constructor(module) {

package/key-value-store/mongo/mongo-key-value.repository.js

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Collection, MongoEntityRepository, noopTransformer } from '../../database/mongo/index.js';
-import { ForwardArg, ResolveArg, Singleton, resolveArgumentType } from '../../injector/index.js';
+import { ForwardArg, ResolveArg, Singleton } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { DEFAULT_KEY_VALUE_REPOSITORY_CONFIG } from './tokens.js';
 const indexes = [

package/lock/lock.js

@@ -1,4 +1,3 @@
-import { resolveArgumentType } from '../injector/index.js';
 export class Lock {
     resource;
     constructor(resource) {

package/lock/mongo/mongo-lock-repository.js

@@ -12,7 +12,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { getNewId } from '../../database/index.js';
 import { Collection, MongoEntityRepository, noopTransformer } from '../../database/mongo/index.js';
-import { ForwardArg, Singleton, resolveArgumentType } from '../../injector/index.js';
+import { ForwardArg, Singleton } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { now } from '../../utils/date-time.js';
 import { MongoError } from 'mongodb';

package/lock/provider.js

@@ -1,3 +1,2 @@
-import { resolveArgumentType } from '../injector/index.js';
 export class LockProvider {
 }

package/logger/logger.js

@@ -1,4 +1,3 @@
-import { resolveArgumentType } from '../injector/index.js';
 import { toArray } from '../utils/array/array.js';
 import { isDefined, isFunction } from '../utils/type-guards.js';
 import { LogLevel } from './level.js';

package/mail/mail.client.js

@@ -7,7 +7,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { resolveArgumentType } from '../injector/index.js';
 import { Property } from '../schema/decorators/property.js';
 import { BooleanProperty } from '../schema/schemas/boolean.js';
 import { Optional } from '../schema/schemas/optional.js';

package/mail/repositories/mongo/mongo-mail-log.repository.js

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Collection, MongoEntityRepository, noopTransformer } from '../../../database/mongo/index.js';
-import { ForwardArg, Singleton, resolveArgumentType } from '../../../injector/index.js';
+import { ForwardArg, Singleton } from '../../../injector/index.js';
 import { Logger } from '../../../logger/index.js';
 export const mongoMailLogRepositoryConfig = {};
 const indexes = [];

package/message-bus/message-bus.js

@@ -1,4 +1,3 @@
-import { resolveArgumentType } from '../injector/interfaces.js';
 import { disposeAsync } from '../disposable/disposable.js';
 export class MessageBus {
     async dispose() {

package/migration/mongo/migration-state-repository.js

@@ -10,7 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { ForwardArg, ResolveArg, Singleton, resolveArgumentType } from '../../injector/index.js';
+import { ForwardArg, ResolveArg, Singleton } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { Collection } from '../../database/mongo/classes.js';
 import { MongoEntityRepository, noopTransformer } from '../../database/mongo/mongo-entity-repository.js';

package/module/modules/web-server.module.js

@@ -12,7 +12,6 @@ import { disposeAsync } from '../../disposable/disposable.js';
 import { HttpServer } from '../../http/server/http-server.js';
 import { Singleton } from '../../injector/decorators.js';
 import { inject, injectArgument } from '../../injector/inject.js';
-import { resolveArgumentType } from '../../injector/interfaces.js';
 import { ModuleBase } from '../module-base.js';
 import { ModuleMetricType } from '../module.js';
 export const webServerModuleConfiguration = {

package/object-storage/object-storage.js

@@ -1,4 +1,3 @@
-import { resolveArgumentType } from '../injector/interfaces.js';
 export class ObjectStorage {
     /** Object storage module */
     module;

package/openid-connect/mongo-oidc-state.repository.js

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Collection, MongoEntityRepository, mapTo } from '../database/mongo/index.js';
-import { ForwardArg, ResolveArg, Singleton, resolveArgumentType } from '../injector/index.js';
+import { ForwardArg, ResolveArg, Singleton } from '../injector/index.js';
 import { Injector } from '../injector/injector.js';
 import { Logger } from '../logger/index.js';
 import { OidcStateRepository } from './oidc-state.repository.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.89",
+  "version": "0.90.91",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -123,15 +123,15 @@
     "@types/mjml": "4.7",
     "@types/node": "20",
     "@types/nodemailer": "6.4",
-    "@typescript-eslint/eslint-plugin": "7.13",
+    "@typescript-eslint/eslint-plugin": "7.14",
     "concurrently": "8.2",
     "eslint": "8.57",
     "eslint-import-resolver-typescript": "3.6",
     "eslint-plugin-import": "2.29",
     "tsc-alias": "1.8",
-    "typedoc": "0.25",
-    "typedoc-plugin-missing-exports": "2.3",
-    "typescript": "5.4"
+    "typedoc": "0.26",
+    "typedoc-plugin-missing-exports": "3.0",
+    "typescript": "5.5"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.14",
@@ -148,7 +148,7 @@
     "mjml": "^4.15",
     "mongodb": "^6.7",
     "nodemailer": "^6.9",
-    "playwright": "^1.44",
+    "playwright": "^1.45",
     "preact": "^10.22",
     "preact-render-to-string": "^6.5",
     "undici": "^6.19",

package/password/password-check.localization.d.ts

@@ -11,8 +11,8 @@ export type PasswordCheckLocalization = Localization<{
 export declare const passwordCheckLocalizationKeys: import("../text/localization.service.js").ProxyLocalizationKeys<{
     tstdl: {
         passwordCheck: {
-            warnings: Record<keyof (typeof zxcvbnTranslationKeys)['default']['warnings'], LocalizeItem>;
-            suggestions: Record<keyof (typeof zxcvbnTranslationKeys)['default']['suggestions'], LocalizeItem>;
+            warnings: Record<keyof (typeof zxcvbnTranslationKeys)["default"]["warnings"], LocalizeItem>;
+            suggestions: Record<keyof (typeof zxcvbnTranslationKeys)["default"]["suggestions"], LocalizeItem>;
         };
     };
 }>;

package/pdf/pdf.service.js

@@ -15,7 +15,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
     if (value !== null && value !== void 0) {
         if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose;
+        var dispose, inner;
         if (async) {
             if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
             dispose = value[Symbol.asyncDispose];
@@ -23,8 +23,10 @@ var __addDisposableResource = (this && this.__addDisposableResource) || function
         if (dispose === void 0) {
             if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
             dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
         }
         if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
         env.stack.push({ value: value, dispose: dispose, async: async });
     }
     else if (async) {
@@ -64,7 +66,7 @@ import { tmpdir } from 'node:os';
 import { BrowserContextController } from '../browser/browser-context-controller.js';
 import { BrowserController } from '../browser/browser-controller.js';
 import { PdfRenderOptions } from '../browser/pdf-options.js';
-import { Singleton, inject, injectArgument, resolveArgumentType } from '../injector/index.js';
+import { Singleton, inject, injectArgument } from '../injector/index.js';
 import { LogLevel } from '../logger/level.js';
 import { Logger } from '../logger/logger.js';
 import { Optional } from '../schema/index.js';

package/queue/mongo/mongo-job.repository.js

@@ -12,7 +12,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { getNewId } from '../../database/index.js';
 import { Collection, MongoEntityRepository, noopTransformer } from '../../database/mongo/index.js';
-import { ForwardArg, ResolveArg, Singleton, resolveArgumentType } from '../../injector/index.js';
+import { ForwardArg, ResolveArg, Singleton } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { UniqueTagStrategy } from '../../queue/index.js';
 const indexes = [

package/queue/mongo/queue.provider.js

@@ -12,7 +12,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { ForwardArg, ResolveArg, Singleton } from '../../injector/decorators.js';
 import { Injector } from '../../injector/injector.js';
-import { resolveArgumentType } from '../../injector/interfaces.js';
 import { LockProvider } from '../../lock/index.js';
 import { MessageBusProvider } from '../../message-bus/index.js';
 import { Queue, QueueProvider } from '../../queue/index.js';

package/queue/queue.js

@@ -1,4 +1,3 @@
-import { resolveArgumentType } from '../injector/interfaces.js';
 import { millisecondsPerMinute } from '../utils/units.js';
 import { QueueEnqueueBatch } from './enqueue-batch.js';
 export const defaultJobPriority = 1000;

package/rpc/endpoints/message-port.rpc-endpoint.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type * as NodeWorkerThreads from 'node:worker_threads';
 import type { Observable } from 'rxjs';
 import type { RpcChannelMessage } from '../rpc.endpoint.js';

package/rpc/rpc.d.ts

@@ -6,16 +6,16 @@ export declare const Rpc: {
     listen(endpoint: RpcEndpoint): void;
     connect<T extends RpcRemoteInput>(endpoint: RpcEndpoint, name?: string): Promise<RpcRemote<T>>;
     expose(object: RpcRemoteInput, name?: string): void;
-    registerAdapter<T_1 extends object, Data>(adapter: RpcAdapter<T_1, Data, any, any, any>): void;
+    registerAdapter<T extends object, Data>(adapter: RpcAdapter<T, Data>): void;
     /**
      * mark object for proxy forward
      * @param object object to forward as proxy
      * @param root if object is a child of the actual passed value (to function calls, returns or whatever), this must be set to to mark the parent for serialization (required for children proxies)
      * @returns
      */
-    proxy<T_2 extends object>(object: T_2, root?: object): T_2;
-    transfer<T_3 extends object>(object: T_3, transfer: any[]): T_3;
-    serialize<T_4 extends object>(object: T_4, options?: SerializationOptions): T_4;
-    adapt<T_5 extends object>(object: T_5, adapter: RpcAdapter<T_5, any, any, any, any>, root?: object): T_5;
+    proxy<T extends object>(object: T, root?: object): T;
+    transfer<T extends object>(object: T, transfer: any[]): T;
+    serialize<T extends object>(object: T, options?: SerializationOptions): T;
+    adapt<T extends object>(object: T, adapter: RpcAdapter<T>, root?: object): T;
     isProxied(object: object): boolean;
 };

package/schema/schema.d.ts

@@ -6,10 +6,10 @@ export type NormalizedSchema<T = any> = NormalizedObjectSchema<T> | NormalizedVa
 export declare const Schema: {
     registerDefaultCoercer(coercer: SchemaValueCoercer): void;
     test<T>(schemaOrValueType: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions, path?: JsonPath): SchemaTestResult<T>;
-    validate<T_1>(schemaOrValueType: SchemaTestable<T_1>, value: unknown, options?: SchemaTestOptions): boolean;
-    parse<T_2>(schemaOrValueType: SchemaTestable<T_2>, value: unknown, options?: SchemaTestOptions): T_2;
-    function<T_3 extends readonly SchemaTestable<any>[], R extends SchemaTestable<any>, F extends (...args: TupleSchemaOutput<T_3>) => SchemaOutput<R>>(argumentSchemas: T_3, returnSchema: R, handler: F): F;
-    asyncFunction<T_4 extends readonly SchemaTestable<any>[], R_1 extends SchemaTestable<any>, F_1 extends (...args: TupleSchemaOutput<T_4>) => Promise<SchemaOutput<R_1>>>(argumentSchemas: T_4, returnSchema: R_1, handler: F_1): F_1;
+    validate<T>(schemaOrValueType: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions): boolean;
+    parse<T>(schemaOrValueType: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions): T;
+    function<T extends readonly SchemaTestable[], R extends SchemaTestable, F extends (...args: TupleSchemaOutput<T>) => SchemaOutput<R>>(argumentSchemas: T, returnSchema: R, handler: F): F;
+    asyncFunction<T extends readonly SchemaTestable[], R extends SchemaTestable, F extends (...args: TupleSchemaOutput<T>) => Promise<SchemaOutput<R>>>(argumentSchemas: T, returnSchema: R, handler: F): F;
 };
 export declare function testSchema<T>(schema: Schema<T>, value: unknown, options?: SchemaTestOptions, path?: JsonPath): SchemaTestResult<T>;
 export declare function getExpectString(schema: SchemaTestable): string;

package/schema/schemas/object.d.ts

@@ -1,7 +1,7 @@
-import type { Record, SimplifiedOptionalize, SimplifyObject, TypedOmit } from '../../types.js';
+import type { ObjectLiteral, Optionalize, Record, SimplifyObject, TypedOmit } from '../../types.js';
 import type { IfNever } from 'type-fest';
-import type { ObjectSchema, ObjectSchemaProperties, TypedObjectSchemaUnknownProperties } from '../types/index.js';
+import { type ObjectSchema, type ObjectSchemaProperties, type TypedObjectSchemaUnknownProperties } from '../types/index.js';
 export type ObjectOptions<T extends Record = Record> = TypedOmit<ObjectSchema<T>, 'properties' | 'unknownProperties' | 'unknownPropertiesKey'>;
 export declare function explicitObject<T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T>): ObjectSchema<T>;
-export declare function object<T extends Record = Record<never>, K extends PropertyKey = any, V = never>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T> & TypedObjectSchemaUnknownProperties<K, V>): ObjectSchema<SimplifyObject<SimplifiedOptionalize<T> & IfNever<V, {}, Record<K, V>>>>;
-export declare const emptyObjectSchema: ObjectSchema<{}>;
+export declare function object<T extends Record = Record<never>, K extends PropertyKey = any, V = never>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T> & TypedObjectSchemaUnknownProperties<K, V>): ObjectSchema<SimplifyObject<Optionalize<T> & IfNever<V, ObjectLiteral, Record<K, V>>>>;
+export declare const emptyObjectSchema: ObjectSchema<ObjectLiteral>;

package/search-index/elastic/config.js

@@ -11,7 +11,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { InjectArg, Injectable } from '../../injector/decorators.js';
-import { resolveArgumentType } from '../../injector/interfaces.js';
 import { isString } from '../../utils/type-guards.js';
 let ElasticSearchIndexConfig = class ElasticSearchIndexConfig {
     indexName;

package/serializer/handlers/binary.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { TypedArray } from '../../types.js';
 interface TypedArrayConstructor {
     readonly BYTES_PER_ELEMENT: number;

package/signals/to-lazy-signal.d.ts

@@ -1 +1,2 @@
-export declare const toLazySignal: typeof import("./implementation/to-signal.js").toSignal;
+import { toSignal } from './api.js';
+export declare const toLazySignal: typeof toSignal;

package/templates/providers/file.template-provider.js

@@ -13,7 +13,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import * as path from 'node:path';
 import { BadRequestError } from '../../errors/bad-request.error.js';
 import { InjectArg, Singleton } from '../../injector/decorators.js';
-import { resolveArgumentType } from '../../injector/interfaces.js';
 import { Schema } from '../../schema/index.js';
 import { Template } from '../template.model.js';
 import { TemplateProvider } from '../template.provider.js';

package/templates/resolvers/file.template-resolver.js

@@ -14,7 +14,6 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { BadRequestError } from '../../errors/bad-request.error.js';
 import { InjectArg, Singleton } from '../../injector/decorators.js';
-import { resolveArgumentType } from '../../injector/interfaces.js';
 import { Property } from '../../schema/index.js';
 import { TemplateField } from '../template.model.js';
 import { TemplateResolver } from '../template.resolver.js';

package/threading/thread-pool.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type * as NodeWorkerThreads from 'node:worker_threads';
 import type { LiteralUnion } from 'type-fest';
 import type { AsyncDisposable } from '../disposable/index.js';

package/types.d.ts

@@ -103,6 +103,7 @@ export type ReplaceIfUnknown<T, U> = IfUnknown<T, U, T>;
 export type OmitNever<T extends Record> = {
     [K in keyof T as T[K] extends never ? never : K]: T[K];
 };
+export type BaseType<T extends Exclude<Primitive, null | undefined>> = T extends string ? string : never | T extends number ? number : never | T extends boolean ? boolean : never | T extends bigint ? bigint : never | T extends symbol ? symbol : never;
 export type SharedProperties<A, B, C = unknown, D = unknown, E = unknown, F = unknown, G = unknown, H = unknown, I = unknown, J = unknown> = OmitNever<Pick<A & B & C & D & E & F & G & H & I & J, keyof A & keyof B & keyof ReplaceIfUnknown<C, never> & keyof ReplaceIfUnknown<D, never> & keyof ReplaceIfUnknown<E, never> & keyof ReplaceIfUnknown<F, never> & keyof ReplaceIfUnknown<G, never> & keyof ReplaceIfUnknown<H, never> & keyof ReplaceIfUnknown<I, never> & keyof ReplaceIfUnknown<J, never>>>;
 /**
  * Omit properties from a type that extend from a specific type.
@@ -114,7 +115,6 @@ export type OmitBy<T, V> = Omit<T, {
  * Normalize properties of a type that allow `undefined` to make them optional.
  */
 export type Optionalize<T extends object> = OmitBy<T, undefined> & Partial<PickBy<T, undefined>>;
-export type SimplifiedOptionalize<T extends object> = SimplifyObject<Optionalize<T>>;
 export type Unoptionalize<T extends object> = SimplifyObject<OmitBy<T, undefined> & {
     [P in PropertiesOfType<T, undefined>]: T[P] | undefined;
 }>;

package/utils/compression.d.ts

@@ -1,6 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import type { Stream } from 'node:stream';
 import type * as NodeZlib from 'node:zlib';
 export interface CompressionResult {

package/utils/factory-map.d.ts

@@ -1,4 +1,4 @@
-export type Factory<Key, Value> = (key: Key) => Value;
+export type Factory<K, V> = (key: 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> {

package/utils/object/forward-ref.d.ts

@@ -11,10 +11,10 @@ export type ForwardRef<T extends object = object> = T & {
 };
 export declare const ForwardRef: {
     create<T extends object>(options?: ForwardRefOptions<T>): ForwardRef<T>;
-    isForwardRef<T_1 extends object = object>(value: any): value is ForwardRef<T_1>;
-    hasRef<T_2 extends object>(forwardRef: T_2 | ForwardRef<T_2>): boolean;
-    deref<T_3 extends object>(forwardRef: T_3 | ForwardRef<T_3>): T_3;
-    tryDeref<T_4 extends object>(forwardRef: T_4 | ForwardRef<T_4>): T_4 | undefined;
-    setRef<T_5 extends object>(forwardRef: T_5 | ForwardRef<T_5>, reference: T_5 | undefined): void;
+    isForwardRef<T extends object = object>(value: any): value is ForwardRef<T>;
+    hasRef<T extends object>(forwardRef: ForwardRef<T> | T): boolean;
+    deref<T extends object>(forwardRef: ForwardRef<T> | T): T;
+    tryDeref<T extends object>(forwardRef: ForwardRef<T> | T): T | undefined;
+    setRef<T extends object>(forwardRef: ForwardRef<T> | T, reference: T | undefined): void;
 };
 export {};

package/utils/object/object.d.ts

@@ -1,5 +1,4 @@
-import type { FromEntries, ObjectLiteral, PickBy, Record, SimplifyObject } from '../../types.js';
-import type { IsEqual } from 'type-fest';
+import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject } from '../../types.js';
 export declare function hasOwnProperty<T extends Record>(obj: T, key: keyof T): boolean;
 /**
  * Returns object entries including those with symbols keys (which Object.entries does not)
@@ -19,10 +18,8 @@ export declare function mapObjectValuesAsync<T extends ObjectLiteral, V>(object:
 export declare function filterObject<T extends ObjectLiteral, U extends T[keyof T]>(object: T, predicate: (value: T[keyof T], key: keyof T) => value is U): PickBy<T, U>;
 export declare function filterObject<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
 export declare function filterObjectAsync<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => Promise<boolean>): Promise<Partial<T>>;
-export declare function filterUndefinedFromRecord<T extends Record>(record: T): T extends Record<infer K, infer V> ? Record<K, Exclude<V, undefined>> : never;
-export declare function filterUndefinedObjectProperties<T extends ObjectLiteral>(object: T): {
-    [P in keyof T]?: IsEqual<T[P], undefined> extends true ? never : Exclude<T[P], undefined>;
-};
+export declare function filterUndefinedFromRecord<K extends PropertyKey, V>(record: Record<K, V>): Record<BaseType<K>, Exclude<V, undefined>>;
+export declare function filterUndefinedObjectProperties<T extends ObjectLiteral>(object: T): SimplifyObject<Optionalize<T>>;
 export declare function copyObjectProperties<T extends ObjectLiteral, U extends T>(source: T, target: U): void;
 export declare function getGetter<T extends ObjectLiteral, U extends keyof T>(obj: T, property: keyof T, bind: boolean): () => T[U];
 export declare function deepObjectEntries(object: ObjectLiteral, keepInnerObjects?: boolean, prefix?: string): [string, any][];

package/utils/repl.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { ReplOptions } from 'node:repl';
 import type { Record } from '../types.js';
 /**

package/utils/stream/stream-helper-types.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 declare const nonObjectBufferModeSymbol: unique symbol;
 declare const nonObjectStringModeSymbol: unique symbol;
 export type NonObjectMode = NonObjectBufferMode | NonObjectStringMode;