@tstdl/base 0.91.50 → 0.91.52

package/orm/transaction.js

@@ -0,0 +1,73 @@
+import { DeferredPromise } from '../promise/deferred-promise.js';
+import { Subject } from 'rxjs';
+export class Transaction {
+    #afterCommitSubject = new Subject();
+    #useCounter = 0;
+    #done = false;
+    afterCommit$ = this.#afterCommitSubject.asObservable();
+    manualCommit = false;
+    withManualCommit() {
+        this.manualCommit = true;
+    }
+    /**
+     * Enters automatic transaction handling. Transaction will be commited when all use-calls are done or rolled back when one throws.
+     */
+    async use(handler) {
+        this.#useCounter++;
+        try {
+            return await handler();
+        }
+        finally {
+            this.#useCounter--;
+            if ((this.#useCounter == 0) && !this.#done && !this.manualCommit) {
+                await this.commit();
+            }
+        }
+    }
+    async commit() {
+        this.#done = true;
+        await this._commit();
+        this.#afterCommitSubject.next();
+        this.#afterCommitSubject.complete();
+    }
+    rollback() {
+        this.#done = true;
+        this._rollback();
+    }
+}
+export class DrizzleTransaction extends Transaction {
+    transaction;
+    deferPromise = new DeferredPromise();
+    pgTransactionPromise;
+    constructor(transaction, pgTransactionPromise) {
+        super();
+        this.transaction = transaction;
+        this.pgTransactionPromise = pgTransactionPromise;
+    }
+    static async create(session, config) {
+        const transactionPromise = new DeferredPromise();
+        const pgTransactionPromise = session.transaction(async (tx) => {
+            const transaction = new DrizzleTransaction(tx, pgTransactionPromise);
+            transactionPromise.resolve(transaction);
+            await transaction.deferPromise;
+        }, config);
+        pgTransactionPromise.catch((error) => {
+            if (transactionPromise.pending) {
+                transactionPromise.reject(error);
+            }
+        });
+        return transactionPromise;
+    }
+    async _commit() {
+        this.deferPromise.resolve();
+        await this.pgTransactionPromise;
+    }
+    _rollback() {
+        try {
+            this.transaction.rollback();
+        }
+        catch (error) {
+            this.deferPromise.reject(error);
+        }
+    }
+}

package/orm/types.d.ts

@@ -1,24 +1,31 @@
-import type { HasDefault as DrizzleHasDefault, IsPrimaryKey as DrizzleIsPrimaryKey } from 'drizzle-orm';
-import type { boolean, doublePrecision, integer, PgColumnBuilder, PgColumnBuilderBase, PgEnumColumnBuilderInitial, text, uuid } from 'drizzle-orm/pg-core';
+import type { $Type, HasDefault as DrizzleHasDefault, IsPrimaryKey as DrizzleIsPrimaryKey } from 'drizzle-orm';
+import type { boolean, date, doublePrecision, integer, jsonb, PgColumnBuilder, PgColumnBuilderBase, PgEnumColumnBuilderInitial, text, timestamp, uuid } from 'drizzle-orm/pg-core';
 import type { GetTagMetadata, Tagged, UnwrapTagged } from 'type-fest';
 import { Array, Integer } from '../schema/index.js';
-import type { EnumerationObject, EnumerationValue, ObjectLiteral, Record, UnionToTuple } from '../types.js';
-import { Uuid } from './schemas/index.js';
+import type { AbstractConstructor, EnumerationObject, EnumerationValue, ObjectLiteral, UnionToTuple } from '../types.js';
+import { Embedded, Unique } from './decorators.js';
+import { Json, NumericDate, Timestamp, Uuid } from './schemas/index.js';
 export type IsPrimaryKey<T> = T extends Tagged<unknown, 'column', PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, 'column', DrizzleIsPrimaryKey<GetTagMetadata<T, 'column'>>> : Tagged<T, 'column', ColumnBuilder<T>>;
 export type HasDefault<T> = T extends Tagged<unknown, 'column', PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, 'column', DrizzleHasDefault<GetTagMetadata<T, 'column'>>> : Tagged<T, 'column', ColumnBuilder<T>>;
-export type Nested<T extends Record> = Tagged<T, 'column', {
-    nested: T;
-}>;
 type EnumColumn<T extends EnumerationObject, ColumnName extends string = ''> = PgEnumColumnBuilderInitial<ColumnName, UnionToTuple<`${EnumerationValue<T>}`> extends [string, ...string[]] ? UnionToTuple<`${EnumerationValue<T>}`> : ['NO_VALUES_PROVIDED']>;
 export type ColumnBuilder<T, ColumnName extends string = never> = T extends Tagged<T, 'column', any> ? GetTagMetadata<T, 'column'> : T extends string ? string extends ColumnName ? ReturnType<typeof text<ColumnName, string, [string, ...string[]]>> : ReturnType<typeof text<string, [string, ...string[]]>> : T extends number ? string extends ColumnName ? ReturnType<typeof doublePrecision<ColumnName>> : ReturnType<typeof doublePrecision> : T extends boolean ? string extends ColumnName ? ReturnType<typeof boolean<ColumnName>> : ReturnType<typeof boolean> : T extends EnumerationObject ? string extends ColumnName ? EnumColumn<T, ColumnName> : EnumColumn<T> : T extends (infer U)[] ? string extends ColumnName ? ReturnType<ColumnBuilder<U, ColumnName>['array']> : ReturnType<ColumnBuilder<U>['array']> : never;
 export type TypeBuilder<T, ColumnName extends string = never> = [
     ColumnName
 ] extends [never] ? T extends Tagged<any, 'column', PgColumnBuilderBase> ? T : T extends infer U ? Tagged<U, 'column', ColumnBuilder<U>> : never : never;
+export declare const embedded: unique symbol;
+export type Embedded<T = AbstractConstructor, P extends string = ''> = T & {
+    [embedded]: {
+        prefix: P;
+    };
+};
 export type Array<T extends Tagged<ObjectLiteral, 'column', PgColumnBuilder<any>>> = Tagged<UnwrapTagged<T>[], 'column', ReturnType<GetTagMetadata<T, 'column'>['array']>>;
+export type Json<T extends ObjectLiteral = ObjectLiteral> = Tagged<T, 'column', $Type<ReturnType<typeof jsonb>, T>>;
 export type Enum<T extends EnumerationObject> = Tagged<EnumerationValue<T>, 'column', EnumColumn<T>>;
 export type Text = Tagged<string, 'column', ReturnType<typeof text<string, [string, ...string[]]>>>;
 export type Uuid = Tagged<string, 'column', ReturnType<typeof uuid>>;
 export type Integer = Tagged<number, 'column', ReturnType<typeof integer>>;
 export type DoublePrecision = Tagged<number, 'column', ReturnType<typeof doublePrecision>>;
 export type Boolean = Tagged<number, 'column', ReturnType<typeof boolean>>;
-export { Array, Integer, Uuid };
+export type NumericDate = Tagged<number, 'column', ReturnType<typeof date>>;
+export type Timestamp = Tagged<number, 'column', ReturnType<typeof timestamp>>;
+export { Array, Embedded, Integer, Json, NumericDate, Timestamp, Unique, Uuid };

package/orm/types.js

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention */
 import { Array, Integer } from '../schema/index.js';
-import { Uuid } from './schemas/index.js';
-export { Array, Integer, Uuid };
+import { Embedded, Unique } from './decorators.js';
+import { Json, NumericDate, Timestamp, Uuid } from './schemas/index.js';
+export { Array, Embedded, Integer, Json, NumericDate, Timestamp, Unique, Uuid };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.50",
+  "version": "0.91.52",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -10,9 +10,11 @@
     "build": "tsc && tsc-alias",
     "build:watch": "concurrently --raw --kill-others npm:tsc:watch npm:tsc-alias:watch",
     "build:production": "rm -rf dist && npm run build && npm run build:production:copy-files",
-    "build:production:copy-files": "cp package.json .eslintrc.json tsconfig.server.json dist/ && cp tsconfig.base.json dist/tsconfig.json",
+    "build:production:copy-files": "cp package.json .eslintrc.json tsconfig.server.json dist/ && cp tsconfig.base.json dist/tsconfig.json && npm run copy:document-management",
     "build:docs": "typedoc",
     "build:docs:watch": "typedoc --watch",
+    "generate:drizzle": "drizzle-kit generate --config dist/document-management/drizzle.config.js",
+    "copy:document-management": "rm -rf ./dist/document-management/drizzle && cp -r ./source/document-management/drizzle ./dist/document-management/",
     "lint": "eslint --config .eslintrc.json --cache source/",
     "pub": "npm run build:production && rm -vf dist/test* && rm -vrf dist/tools/ && npm publish dist/",
     "tsc:watch": "tsc --watch",
@@ -79,7 +81,7 @@
     "./reflection": "./reflection/index.js",
     "./rpc": "./rpc/index.js",
     "./rpc/endpoints": "./rpc/endpoints/index.js",
-    "./rxjs": "./rxjs/index.js",
+    "./rxjs": "./rxjs-utils/index.js",
     "./schema": "./schema/index.js",
     "./search-index": "./search-index/index.js",
     "./search-index/elastic": "./search-index/elastic/index.js",
@@ -115,11 +117,11 @@
     "luxon": "^3.5",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.30"
+    "type-fest": "4.31"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
-    "@stylistic/eslint-plugin": "2.11",
+    "@stylistic/eslint-plugin": "2.12",
     "@types/chroma-js": "2.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.4",
@@ -128,19 +130,21 @@
     "@types/node": "22",
     "@types/nodemailer": "6.4",
     "@types/pg": "8.11",
-    "@typescript-eslint/eslint-plugin": "8.17",
+    "@typescript-eslint/eslint-plugin": "8.19",
     "concurrently": "9.1",
-    "drizzle-kit": "0.28",
+    "drizzle-kit": "0.30",
     "eslint": "8.57",
-    "eslint-import-resolver-typescript": "3.6",
+    "eslint-import-resolver-typescript": "3.7",
     "eslint-plugin-import": "2.31",
     "tsc-alias": "1.8",
+    "tsx": "^4.19.2",
     "typedoc": "0.27",
     "typedoc-plugin-missing-exports": "3.1",
     "typescript": "5.6"
   },
   "peerDependencies": {
-    "@elastic/elasticsearch": "^8.16",
+    "@elastic/elasticsearch": "^8.17",
+    "@google/generative-ai": "^0.21",
     "@koa/router": "^13.1",
     "@tstdl/angular": "^0.91",
     "@zxcvbn-ts/core": "^3.0",
@@ -148,23 +152,30 @@
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.6",
-    "drizzle-orm": "^0.36",
+    "drizzle-orm": "^0.38",
     "handlebars": "^4.7",
     "koa": "^2.15",
     "minio": "^8.0",
     "mjml": "^4.15",
-    "mongodb": "^6.11",
+    "mongodb": "^6.12",
     "nodemailer": "^6.9",
     "pg": "8.13",
     "playwright": "^1.49",
     "preact": "^10.25",
     "preact-render-to-string": "^6.5",
-    "undici": "^6.21",
+    "undici": "^7.2",
     "urlpattern-polyfill": "^10.0"
   },
   "peerDependenciesMeta": {
     "@tstdl/angular": {
       "optional": true
     }
+  },
+  "overrides": {
+    "drizzle-kit": {
+      "@esbuild-kit/esm-loader": "^2.6",
+      "esbuild": "^0.24",
+      "esbuild-register": "^3.6"
+    }
   }
 }

package/{rxjs → rxjs-utils}/reject-error.d.ts

@@ -1,2 +1,2 @@
-import type { MonoTypeOperatorFunction } from 'rxjs';
+import { type MonoTypeOperatorFunction } from 'rxjs';
 export declare function rejectErrors<T>(): MonoTypeOperatorFunction<T>;

package/{rxjs → rxjs-utils}/retry-backoff.d.ts

@@ -1,4 +1,4 @@
-import type { BackoffOptions } from '../utils/backoff.js';
-import type { MonoTypeOperatorFunction, ObservableInput } from 'rxjs';
+import { type BackoffOptions } from '../utils/backoff.js';
+import { type MonoTypeOperatorFunction, type ObservableInput } from 'rxjs';
 export declare function retryBackoff<T>(count: number, options: BackoffOptions): MonoTypeOperatorFunction<T>;
 export declare function retryBackoffHandled<T>(count: number, options: BackoffOptions, handler: (error: Error, count: number) => void | undefined | ObservableInput<void>): MonoTypeOperatorFunction<T>;

package/{rxjs → rxjs-utils}/slow-array.d.ts

@@ -1,30 +1,30 @@
-import type { MonoTypeOperatorFunction, Observable } from 'rxjs';
+import { type MonoTypeOperatorFunction, type Observable } from 'rxjs';
 export type SlowArrayOptions = {
     /**
-     * delay before emitting the first array
+     * Delay before emitting the first array
      */
     delay?: number;
     /**
-     * initial emitted array size
+     * Initial emitted array size
      */
     initialSize?: number;
     /**
-     * interval between each addition of more items
+     * Interval between each addition of more items
      */
     interval: number;
     /**
-     * how many items to add each interval
+     * How many items to add each interval
      */
     size: number;
 };
 /**
- * emits arrays
+ * Emits arrays
  * @param array array to take items from
  * @param options options
  */
 export declare function slowArray<T>(array: T[], options: SlowArrayOptions): Observable<T[]>;
 /**
- * emits arrays - keeping length when changing source array
+ * Emits arrays - keeping length when changing source array
  * @param array array observable to take items from
  * @param options options
  */

package/{rxjs → rxjs-utils}/slow-array.js

@@ -1,6 +1,6 @@
 import { map, of, switchMap, takeWhile, timer } from 'rxjs';
 /**
- * emits arrays
+ * Emits arrays
  * @param array array to take items from
  * @param options options
  */
@@ -8,7 +8,7 @@ export function slowArray(array, options) {
     return of(array).pipe(persistentSlowArray(options));
 }
 /**
- * emits arrays - keeping length when changing source array
+ * Emits arrays - keeping length when changing source array
  * @param array array observable to take items from
  * @param options options
  */

package/{rxjs → rxjs-utils}/start-with-provider.d.ts

@@ -1,2 +1,2 @@
-import type { OperatorFunction } from 'rxjs';
+import { type OperatorFunction } from 'rxjs';
 export declare function startWithProvider<T, D>(valueProvider: () => D): OperatorFunction<T, T | D>;

package/{rxjs → rxjs-utils}/teardown.d.ts

@@ -1,2 +1,2 @@
-import type { OperatorFunction } from 'rxjs';
+import { type OperatorFunction } from 'rxjs';
 export declare function teardown<T>(teardownFn: (lastValue: T | undefined, lastError: any) => unknown): OperatorFunction<T, T>;

package/{rxjs → rxjs-utils}/untrack.d.ts

@@ -1,2 +1,2 @@
-import type { MonoTypeOperatorFunction } from 'rxjs';
+import { type MonoTypeOperatorFunction } from 'rxjs';
 export declare function untrack<T>(): MonoTypeOperatorFunction<T>;

package/schema/decorators/types.d.ts

@@ -1,11 +1,11 @@
 import type { Decorator } from '../../reflection/types.js';
 import type { SchemaTestable } from '../schema.js';
-import type { ObjectSchemaFactoryFunction, ObjectSchemaOptions } from '../schemas/object.js';
+import type { ObjectSchemaFactory, ObjectSchemaOptions } from '../schemas/object.js';
 export type SchemaClassDecorator = Decorator<'class'>;
 export type SchemaPropertyDecorator = Decorator<'property' | 'accessor'>;
 export type SchemaTypeReflectionData = Partial<Pick<ObjectSchemaOptions, 'mask' | 'unknownProperties' | 'unknownPropertiesKey'>> & {
     schema?: SchemaTestable;
-    factory?: ObjectSchemaFactoryFunction<any>;
+    factory?: ObjectSchemaFactory<any>;
 };
 export type SchemaPropertyReflectionData = {
     schema?: SchemaTestable;

package/schema/schemas/number.d.ts

@@ -6,7 +6,7 @@ export type NumberSchemaOptions = SimpleSchemaOptions & {
     maximum?: number;
 };
 export declare class NumberSchema extends SimpleSchema<number> {
-    readonly name = "number";
+    readonly name: string;
     readonly integer: boolean;
     readonly minimum: number | null;
     readonly maximum: number | null;

package/signals/pipe.d.ts

@@ -1,5 +1,5 @@
 import { type OperatorFunction } from 'rxjs';
-import type { Signal } from './api.js';
+import { type Signal } from './api.js';
 /**
  * As we need an synchronous value for the resulting signal and effect scheduling is async, it uses the source signals value as the initial value for the pipe.
  * This would normally result in double emission inside the pipe, but is mitigated by using {@link SignalPipeOptions.distinctUntilChanged}. Because of this, mutating source signals are not supported.

package/signals/pipe.js

@@ -1,6 +1,5 @@
 import { distinctUntilChanged } from 'rxjs';
-import { startWithProvider } from '../rxjs/start-with-provider.js';
-import { untrack } from '../rxjs/untrack.js';
+import { startWithProvider, untrack } from '../rxjs-utils/index.js';
 import { toObservable, toSignal } from './api.js';
 export function pipe(source, ...operators) {
     return rawPipe(source, startWithProvider(source), distinctUntilChanged(), ...operators);

package/sse/server-sent-events.d.ts

@@ -1,21 +1,75 @@
 import { type Observable } from 'rxjs';
+/**
+ * Represents the possible states of a Server-Sent Events connection.
+ */
 export declare enum ServerSentEventsState {
+    /**
+     * The connection is currently being established.
+     */
     Connecting = 0,
+    /**
+     * The connection is open and ready to receive events.
+     */
     Open = 1,
+    /**
+     * The connection is closed.
+     */
     Closed = 2
 }
+/**
+ * A wrapper around the EventSource API, providing an RxJS-friendly interface for Server-Sent Events.
+ */
 export declare class ServerSentEvents {
     private readonly eventSource;
     private readonly closeSubject;
+    /**
+     * An observable that emits when the connection is open.
+     */
     readonly open$: Observable<void>;
+    /**
+     * An observable that emits when the connection is closed.
+     */
     readonly close$: Observable<void>;
+    /**
+     * An observable that emits when an error occurs with the connection.
+     */
     readonly error$: Observable<Event>;
+    /**
+     * An observable that emits the current state of the connection.
+     */
     readonly state$: Observable<ServerSentEventsState>;
+    /**
+     * An observable that emits `true` when the connection is in the 'Connecting' state, `false` otherwise.
+     */
     readonly isConnecting$: Observable<boolean>;
+    /**
+     * An observable that emits `true` when the connection is in the 'Open' state, `false` otherwise.
+     */
     readonly isOpen$: Observable<boolean>;
+    /**
+     * An observable that emits `true` when the connection is in the 'Closed' state, `false` otherwise.
+     */
     readonly isClosed$: Observable<boolean>;
+    /**
+     * Gets the current state of the Server-Sent Events connection.
+     * @returns The current state.
+     * @throws If the readyState of the EventSource is unknown.
+     */
     get state(): ServerSentEventsState;
+    /**
+     * Creates a new ServerSentEvents instance.
+     * @param url The URL of the server-sent events endpoint.
+     * @param options Optional EventSource initialization options.
+     */
     constructor(url: string, options?: EventSourceInit);
+    /**
+     * Returns an observable of message events for a specific event type or default to 'message' event.
+     * @param event The event type to listen for. Defaults to 'message'.
+     * @returns An observable of message events.
+     */
     message$(event?: string): Observable<MessageEvent<string>>;
+    /**
+     * Closes the Server-Sent Events connection.
+     */
     close(): void;
 }

package/sse/server-sent-events.js

@@ -1,21 +1,62 @@
 import { NotSupportedError } from '../errors/not-supported.error.js';
 import { ReplaySubject, distinctUntilChanged, filter, fromEvent, map, merge, share, shareReplay, startWith, takeUntil } from 'rxjs';
+/**
+ * Represents the possible states of a Server-Sent Events connection.
+ */
 export var ServerSentEventsState;
 (function (ServerSentEventsState) {
+    /**
+     * The connection is currently being established.
+     */
     ServerSentEventsState[ServerSentEventsState["Connecting"] = 0] = "Connecting";
+    /**
+     * The connection is open and ready to receive events.
+     */
     ServerSentEventsState[ServerSentEventsState["Open"] = 1] = "Open";
+    /**
+     * The connection is closed.
+     */
     ServerSentEventsState[ServerSentEventsState["Closed"] = 2] = "Closed";
 })(ServerSentEventsState || (ServerSentEventsState = {}));
+/**
+ * A wrapper around the EventSource API, providing an RxJS-friendly interface for Server-Sent Events.
+ */
 export class ServerSentEvents {
     eventSource;
     closeSubject;
+    /**
+     * An observable that emits when the connection is open.
+     */
     open$;
+    /**
+     * An observable that emits when the connection is closed.
+     */
     close$;
+    /**
+     * An observable that emits when an error occurs with the connection.
+     */
     error$;
+    /**
+     * An observable that emits the current state of the connection.
+     */
     state$;
+    /**
+     * An observable that emits `true` when the connection is in the 'Connecting' state, `false` otherwise.
+     */
     isConnecting$;
+    /**
+     * An observable that emits `true` when the connection is in the 'Open' state, `false` otherwise.
+     */
     isOpen$;
+    /**
+     * An observable that emits `true` when the connection is in the 'Closed' state, `false` otherwise.
+     */
     isClosed$;
+    /**
+     * Gets the current state of the Server-Sent Events connection.
+     * @returns The current state.
+     * @throws If the readyState of the EventSource is unknown.
+     */
     get state() {
         switch (this.eventSource.readyState) {
             case EventSource.CONNECTING:
@@ -28,6 +69,11 @@ export class ServerSentEvents {
                 throw new NotSupportedError(`Unknown EventSource readyState ${this.eventSource.readyState}`);
         }
     }
+    /**
+     * Creates a new ServerSentEvents instance.
+     * @param url The URL of the server-sent events endpoint.
+     * @param options Optional EventSource initialization options.
+     */
     constructor(url, options) {
         this.eventSource = new EventSource(url, options);
         this.closeSubject = new ReplaySubject(1);
@@ -40,9 +86,17 @@ export class ServerSentEvents {
         this.isClosed$ = this.state$.pipe(map((state) => state == ServerSentEventsState.Closed), shareReplay({ bufferSize: 1, refCount: true }));
         this.open$ = this.isOpen$.pipe(filter((open) => open), map(() => undefined), takeUntil(this.close$), share());
     }
+    /**
+     * Returns an observable of message events for a specific event type or default to 'message' event.
+     * @param event The event type to listen for. Defaults to 'message'.
+     * @returns An observable of message events.
+     */
     message$(event) {
         return fromEvent(this.eventSource, event ?? 'message').pipe(takeUntil(this.close$));
     }
+    /**
+     * Closes the Server-Sent Events connection.
+     */
     close() {
         this.eventSource.close();
         this.closeSubject.next();

package/types.d.ts

@@ -1,5 +1,5 @@
 import type { Observable } from 'rxjs';
-import type { CamelCase, Except, IsEqual, LiteralUnion } from 'type-fest';
+import type { CamelCase, Except, IsEqual, LiteralUnion, Tagged, UnwrapTagged } from 'type-fest';
 import type { Signal } from './signals/api.js';
 export type ObjectLiteral = {};
 export type PrimitiveTypeMap = {
@@ -210,5 +210,9 @@ export type OmitDeep<T, S extends OmitDeepSelection<T>> = T extends Record<any>
         S[Extract<P, keyof S>]
     ] extends ([false] | [never]) ? T[P] : S[Extract<P, keyof S>] extends Record<any> ? T[P] extends (infer U)[] ? S[Extract<P, keyof S>] extends OmitDeepSelection<U> ? OmitDeep<U, S[Extract<P, keyof S>]>[] : never : S[Extract<P, keyof S>] extends OmitDeepSelection<T[P]> ? OmitDeep<T[P], S[Extract<P, keyof S>]> : never : never;
 }> : T;
+export type Untagged<T> = T extends Tagged<unknown, any, any> ? UnwrapTagged<T> : T;
+export type UntaggedDeep<T> = T extends Tagged<unknown, any, any> ? UnwrapTagged<T> : T extends readonly (infer U)[] ? UntaggedDeep<U>[] : T extends Record ? {
+    [P in keyof T]: UntaggedDeep<T[P]>;
+} : Untagged<T>;
 export type AnyFunction = Function;
 export {};

package/utils/comparison.d.ts

@@ -2,6 +2,7 @@ export declare function compareByValueSelection<T>(...selectors: ((item: T) => u
 export declare function compareByValueSelectionDescending<T>(...selectors: ((item: T) => unknown)[]): (a: T, b: T) => number;
 export declare function compareByValueSelectionOrdered<T>(...selectors: (readonly [(item: T) => unknown, 1 | -1])[]): (a: T, b: T) => number;
 export declare function compareByValueToOrder<T>(order: T[]): (a: T, b: T) => number;
-export declare function compareByValueSelectionToOrder<T, TSelect>(order: TSelect[], selector: (item: T) => TSelect): (a: T, b: T) => number;
+export declare const orderRest: unique symbol;
+export declare function compareByValueSelectionToOrder<T, TSelect>(order: (TSelect | typeof orderRest)[], selector: (item: T) => TSelect): (a: T, b: T) => number;
 export declare function compareByValue<T>(a: T, b: T): number;
 export declare function compareByValueDescending<T>(a: T, b: T): number;

package/utils/comparison.js

@@ -42,6 +42,7 @@ export function compareByValueSelectionOrdered(...selectors) {
 export function compareByValueToOrder(order) {
     return compareByValueSelectionToOrder(order, (item) => item);
 }
+export const orderRest = Symbol('Order rest');
 export function compareByValueSelectionToOrder(order, selector) {
     const indexMapEntries = order.map((orderItem, index) => [orderItem, index]);
     const indexMap = new Map(indexMapEntries);
@@ -49,10 +50,10 @@ export function compareByValueSelectionToOrder(order, selector) {
     return function compareByValueSelectionToOrder(a, b) {
         const selectedA = selector(a);
         const selectedB = selector(b);
-        const indexA = indexMap.get(selectedA);
-        const indexB = indexMap.get(selectedB);
+        const indexA = indexMap.get(selectedA) ?? indexMap.get(orderRest);
+        const indexB = indexMap.get(selectedB) ?? indexMap.get(orderRest);
         if (indexA == undefined || indexB == undefined) {
-            throw new Error('value not defined in order');
+            throw new Error('Value not defined in order.');
         }
         return compareByValue(indexA, indexB);
     };

package/utils/compression.d.ts

@@ -1,4 +1,4 @@
-import type { Stream } from 'node:stream';
+import type * as NodeStream from 'node:stream';
 import type * as NodeZlib from 'node:zlib';
 export interface CompressionResult {
     toBuffer(): Promise<Uint8Array>;
@@ -23,6 +23,6 @@ export declare function decompressString(input: string, encoding: BufferEncoding
 export declare function decompress(buffer: NodeZlib.InputType, algorithm: 'gzip' | 'deflate' | 'deflate-raw', options?: NodeZlib.ZlibOptions): DecompressionResult;
 export declare function decompress(buffer: NodeZlib.InputType, algorithm: 'brotli', options?: NodeZlib.BrotliOptions): DecompressionResult;
 export declare function decompress(buffer: NodeZlib.InputType, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): DecompressionResult;
-export declare function decompressStream(stream: Stream | ReadableStream, algorithm: 'gzip' | 'deflate' | 'deflate-raw', options?: NodeZlib.ZlibOptions): ReadableStream<Uint8Array>;
-export declare function decompressStream(stream: Stream | ReadableStream, algorithm: 'brotli', options?: NodeZlib.BrotliOptions): ReadableStream<Uint8Array>;
-export declare function decompressStream(stream: Stream | ReadableStream, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): ReadableStream<Uint8Array>;
+export declare function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: 'gzip' | 'deflate' | 'deflate-raw', options?: NodeZlib.ZlibOptions): ReadableStream<Uint8Array>;
+export declare function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: 'brotli', options?: NodeZlib.BrotliOptions): ReadableStream<Uint8Array>;
+export declare function decompressStream(stream: NodeStream.Readable | ReadableStream, algorithm: CompressionAlgorithm, options?: NodeZlib.ZlibOptions | NodeZlib.BrotliOptions): ReadableStream<Uint8Array>;