@tstdl/base 0.92.124 → 0.92.126

package/utils/reactive-value-to-signal.d.ts

@@ -0,0 +1,20 @@
+import { type Signal, type ToSignalOptions } from '../signals/api.js';
+import type { ReactiveValue } from '../types.js';
+export type ReactiveValueToSignalOptions<T> = ToSignalOptions<T>;
+export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>): Signal<T | undefined>;
+export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T | undefined> & {
+    initialValue?: undefined;
+    requireSync?: false;
+}): Signal<T | undefined>;
+export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T | null> & {
+    initialValue?: null;
+    requireSync?: false;
+}): Signal<T | null>;
+export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T> & {
+    initialValue?: undefined;
+    requireSync: true;
+}): Signal<T>;
+export declare function reactiveValueToSignal<T, const I>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T | I> & {
+    initialValue: I;
+    requireSync?: false;
+}): Signal<T | I>;

package/utils/reflection.d.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata/lite';
+import type { Type } from '../types.js';
+export declare function getDesignType(target: object, propertyKey?: string | symbol): Type;
+export declare function hasDesignType(target: object, propertyKey?: string | symbol): boolean;
+export declare function getParameterTypes(target: object, propertyKey?: string | symbol): Type[] | undefined;
+export declare function hasParameterTypes(target: object, propertyKey?: string | symbol): boolean;
+export declare function getReturnType(target: object, propertyKey?: string | symbol): Type;
+export declare function hasReturnType(target: object, propertyKey?: string | symbol): boolean;

package/utils/repl.d.ts

@@ -0,0 +1,9 @@
+import type { ReplOptions } from 'node:repl';
+import type { Record } from '../types.js';
+/**
+ * Starts an interactive (repl) session (node only)
+ * @param context context to set the repl context to
+ */
+export declare function repl(options?: ReplOptions & {
+    context?: Record<string, unknown>;
+}): Promise<void>;

package/utils/singleton.d.ts

@@ -0,0 +1,7 @@
+import type { ObjectLiteral } from '../types.js';
+export type Builder<T> = () => T;
+export type AsyncBuilder<T> = () => Promise<T>;
+export declare function singleton<T>(type: ObjectLiteral, builder: Builder<T>): T;
+export declare function singleton<T>(type: ObjectLiteral, builder: AsyncBuilder<T>): Promise<T>;
+export declare function singleton<T>(scope: ObjectLiteral, type: ObjectLiteral, builder: Builder<T>): T;
+export declare function singleton<T>(scope: ObjectLiteral, type: ObjectLiteral, builder: AsyncBuilder<T>): Promise<T>;

package/utils/stream/size-limited-stream.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryData } from '../../types.js';
+export declare function sizeLimitTransform<T extends BinaryData>(maxBytes: number, writableStrategy?: QueuingStrategy<T>, readableStrategy?: QueuingStrategy<T>): TransformStream<T, T>;

package/utils/timing.d.ts

@@ -0,0 +1,20 @@
+import { type Observable } from 'rxjs';
+import { CancellationSignal } from '../cancellation/token.js';
+import { type ValueOrProvider } from './value-or-provider.js';
+/** Timeout for specified duration */
+export declare function timeout(milliseconds?: number, options?: {
+    abortSignal?: AbortSignal;
+}): Promise<void>;
+/** Timeout until specified time */
+export declare function timeoutUntil(timestamp: number | Date): Promise<void>;
+/** Timeout for specified duration */
+export declare function cancelableTimeout(milliseconds: number, cancelSignal: Observable<void> | CancellationSignal): Promise<boolean>;
+/** Timeout until specified time */
+export declare function cancelableTimeoutUntil(timestamp: number | Date, cancelSignal: Observable<void> | CancellationSignal): Promise<boolean>;
+export declare function withTimeout<T>(milliseconds: number, promiseOrProvider: ValueOrProvider<Promise<T>>, options?: {
+    errorMessage?: string;
+}): Promise<T>;
+export declare function immediate(): Promise<void>;
+export declare function nextTick(): Promise<void>;
+export declare function animationFrame(): Promise<number>;
+export declare function idle(timeout?: number): Promise<IdleDeadline>;

package/utils/try-ignore.d.ts

@@ -0,0 +1,9 @@
+import type { Logger } from '../logger/logger.js';
+export declare function tryIgnore<R>(fn: () => R): R;
+export declare function tryIgnore<R, F>(fn: () => R, fallback: F): R | F;
+export declare function tryIgnoreAsync<R>(fn: () => Promise<R>): Promise<R>;
+export declare function tryIgnoreAsync<R, F>(fn: () => Promise<R>, fallback: F): Promise<F>;
+export declare function tryIgnoreLog<R>(logger: Logger, fn: () => R): R;
+export declare function tryIgnoreLog<R, F>(logger: Logger, fn: () => R, fallback: F): R | F;
+export declare function tryIgnoreLogAsync<R>(logger: Logger, fn: () => Promise<R>): Promise<R>;
+export declare function tryIgnoreLogAsync<R, F>(logger: Logger, fn: () => Promise<R>, fallback: F): Promise<F>;

package/utils/type/extends.d.ts

@@ -0,0 +1,3 @@
+import type { AbstractConstructor } from '../../types.js';
+export declare function typeExtends<Type extends AbstractConstructor, Base extends Type>(type: Type, base: Base): type is Base;
+export declare function typeExtends<Base extends AbstractConstructor>(type: AbstractConstructor, base: Base): type is Base;

package/utils/type-guards.d.ts

@@ -0,0 +1,259 @@
+import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, TypedArray } from '../types.js';
+export type AssertionMessage = string | (() => string);
+export type IsFunction<T> = <U extends T = T>(value: any) => value is U;
+export type IsNotFunction<T> = <V>(value: V) => value is Exclude<V, T>;
+export type AssertFunction<T> = <U extends T = T>(value: any, message?: AssertionMessage) => asserts value is U;
+export type AssertNotFunction<T> = <V>(value: V, message?: AssertionMessage) => asserts value is Exclude<V, T>;
+export type AssertPassFunction<T> = <U extends T = T>(value: any, message?: AssertionMessage) => U;
+export type AssertNotPassFunction<T> = <V>(value: V, message?: AssertionMessage) => Exclude<V, T>;
+export type GuardFunctions<N extends string, T> = Record<`is${PascalCase<N>}`, IsFunction<T>> & Record<`isNot${PascalCase<N>}`, IsNotFunction<T>> & Record<`assert${PascalCase<N>}`, AssertFunction<T>> & Record<`assertNot${PascalCase<N>}`, AssertNotFunction<T>> & Record<`assert${PascalCase<N>}Pass`, AssertPassFunction<T>> & Record<`assertNot${PascalCase<N>}Pass`, AssertNotPassFunction<T>>;
+export declare function assert(condition: boolean, message?: AssertionMessage): asserts condition;
+export declare function assertNot(condition: boolean, message?: AssertionMessage): asserts condition;
+export declare function createGuards<N extends string, T>(name: N, testFn: (value: any) => value is T): GuardFunctions<N, T>;
+export declare function createInstanceGuards<N extends string, T>(name: N, type: AbstractConstructor<T>): GuardFunctions<N, T>;
+export declare const isUndefined: IsFunction<undefined | void>;
+export declare const isDefined: IsNotFunction<undefined | void>;
+export declare const assertUndefined: AssertFunction<undefined | void>;
+export declare const assertDefined: AssertNotFunction<undefined | void>;
+export declare const assertUndefinedPass: AssertPassFunction<undefined | void>;
+export declare const assertDefinedPass: AssertNotPassFunction<undefined | void>;
+export declare const isNull: IsFunction<null>;
+export declare const isNotNull: IsNotFunction<null>;
+export declare const assertNull: AssertFunction<null>;
+export declare const assertNotNull: AssertNotFunction<null>;
+export declare const assertNullPass: AssertPassFunction<null>;
+export declare const assertNotNullPass: AssertNotPassFunction<null>;
+export declare const isNullOrUndefined: (value: any) => value is null | undefined;
+export declare const isNotNullOrUndefined: IsNotFunction<null | undefined | void>;
+export declare const assertNullOrUndefined: (value: any, message?: AssertionMessage) => asserts value is null | undefined;
+export declare const assertNotNullOrUndefined: AssertNotFunction<null | undefined | void>;
+export declare const assertNullOrUndefinedPass: (value: any, message?: AssertionMessage) => null | undefined;
+export declare const assertNotNullOrUndefinedPass: AssertNotPassFunction<null | undefined | void>;
+export declare const isNumber: IsFunction<number>;
+export declare const isNotNumber: IsNotFunction<number>;
+export declare const assertNumber: AssertFunction<number>;
+export declare const assertNotNumber: AssertNotFunction<number>;
+export declare const assertNumberPass: AssertPassFunction<number>;
+export declare const assertNotNumberPass: AssertNotPassFunction<number>;
+export declare const isString: IsFunction<string>;
+export declare const isNotString: IsNotFunction<string>;
+export declare const assertString: AssertFunction<string>;
+export declare const assertNotString: AssertNotFunction<string>;
+export declare const assertStringPass: AssertPassFunction<string>;
+export declare const assertNotStringPass: AssertNotPassFunction<string>;
+export declare const isBoolean: IsFunction<boolean>;
+export declare const isNotBoolean: IsNotFunction<boolean>;
+export declare const assertBoolean: AssertFunction<boolean>;
+export declare const assertNotBoolean: AssertNotFunction<boolean>;
+export declare const assertBooleanPass: AssertPassFunction<boolean>;
+export declare const assertNotBooleanPass: AssertNotPassFunction<boolean>;
+export declare const isBigInt: IsFunction<bigint>;
+export declare const isNotBigInt: IsNotFunction<bigint>;
+export declare const assertBigInt: AssertFunction<bigint>;
+export declare const assertNotBigInt: AssertNotFunction<bigint>;
+export declare const assertBigIntPass: AssertPassFunction<bigint>;
+export declare const assertNotBigIntPass: AssertNotPassFunction<bigint>;
+export declare const isFunction: IsFunction<Function>;
+export declare const isNotFunction: IsNotFunction<Function>;
+export declare const assertFunction: AssertFunction<Function>;
+export declare const assertNotFunction: AssertNotFunction<Function>;
+export declare const assertFunctionPass: AssertPassFunction<Function>;
+export declare const assertNotFunctionPass: AssertNotPassFunction<Function>;
+export declare const isSymbol: IsFunction<symbol>;
+export declare const isNotSymbol: IsNotFunction<symbol>;
+export declare const assertSymbol: AssertFunction<symbol>;
+export declare const assertNotSymbol: AssertNotFunction<symbol>;
+export declare const assertSymbolPass: AssertPassFunction<symbol>;
+export declare const assertNotSymbolPass: AssertNotPassFunction<symbol>;
+export declare const isLiteralObject: IsFunction<object>;
+export declare const isNotLiteralObject: IsNotFunction<object>;
+export declare const assertLiteralObject: AssertFunction<object>;
+export declare const assertNotLiteralObject: AssertNotFunction<object>;
+export declare const assertLiteralObjectPass: AssertPassFunction<object>;
+export declare const assertNotLiteralObjectPass: AssertNotPassFunction<object>;
+export declare const isObject: IsFunction<object>;
+export declare const isNotObject: IsNotFunction<object>;
+export declare const assertObject: AssertFunction<object>;
+export declare const assertNotObject: AssertNotFunction<object>;
+export declare const assertObjectPass: AssertPassFunction<object>;
+export declare const assertNotObjectPass: AssertNotPassFunction<object>;
+export declare const isPrimitive: IsFunction<Primitive>;
+export declare const isNotPrimitive: IsNotFunction<Primitive>;
+export declare const assertPrimitive: AssertFunction<Primitive>;
+export declare const assertNotPrimitive: AssertNotFunction<Primitive>;
+export declare const assertPrimitivePass: AssertPassFunction<Primitive>;
+export declare const assertNotPrimitivePass: AssertNotPassFunction<Primitive>;
+export declare const isJsonPrimitive: IsFunction<JsonPrimitive>;
+export declare const isNotJsonPrimitive: IsNotFunction<JsonPrimitive>;
+export declare const assertJsonPrimitive: AssertFunction<JsonPrimitive>;
+export declare const assertNotJsonPrimitive: AssertNotFunction<JsonPrimitive>;
+export declare const assertJsonPrimitivePass: AssertPassFunction<JsonPrimitive>;
+export declare const assertNotJsonPrimitivePass: AssertNotPassFunction<JsonPrimitive>;
+export declare const isDate: IsFunction<Date>;
+export declare const isNotDate: IsNotFunction<Date>;
+export declare const assertDate: AssertFunction<Date>;
+export declare const assertNotDate: AssertNotFunction<Date>;
+export declare const assertDatePass: AssertPassFunction<Date>;
+export declare const assertNotDatePass: AssertNotPassFunction<Date>;
+export declare const isValidDate: IsFunction<Date>;
+export declare const isNotValidDate: IsNotFunction<Date>;
+export declare const assertValidDate: AssertFunction<Date>;
+export declare const assertNotValidDate: AssertNotFunction<Date>;
+export declare const assertValidDatePass: AssertPassFunction<Date>;
+export declare const assertNotValidDatePass: AssertNotPassFunction<Date>;
+export declare const isRegExp: IsFunction<RegExp>;
+export declare const isNotRegExp: IsNotFunction<RegExp>;
+export declare const assertRegExp: AssertFunction<RegExp>;
+export declare const assertNotRegExp: AssertNotFunction<RegExp>;
+export declare const assertRegExpPass: AssertPassFunction<RegExp>;
+export declare const assertNotRegExpPass: AssertNotPassFunction<RegExp>;
+export declare const isArray: <T = any>(value: any) => value is readonly T[];
+export declare const isNotArray: IsNotFunction<readonly any[]>;
+export declare const assertArray: <T = any>(value: any, message?: AssertionMessage) => asserts value is readonly T[];
+export declare const assertNotArray: AssertNotFunction<readonly any[]>;
+export declare const assertArrayPass: <T = any>(value: any, message?: AssertionMessage) => readonly T[];
+export declare const assertNotArrayPass: AssertNotPassFunction<readonly any[]>;
+export declare const isWritableArray: <T = any>(value: any) => value is T[];
+export declare const isNotWritableArray: IsNotFunction<any[]>;
+export declare const assertWritableArray: <T = any>(value: any, message?: AssertionMessage) => asserts value is T[];
+export declare const assertNotWritableArray: AssertNotFunction<any[]>;
+export declare const assertWritableArrayPass: <T = any>(value: any, message?: AssertionMessage) => T[];
+export declare const assertNotWritableArrayPass: AssertNotPassFunction<any[]>;
+export declare const isBlob: IsFunction<Blob>;
+export declare const isNotBlob: IsNotFunction<Blob>;
+export declare const assertBlob: AssertFunction<Blob>;
+export declare const assertNotBlob: AssertNotFunction<Blob>;
+export declare const assertBlobPass: AssertPassFunction<Blob>;
+export declare const assertNotBlobPass: AssertNotPassFunction<Blob>;
+export declare const isArrayBuffer: IsFunction<ArrayBuffer>;
+export declare const isNotArrayBuffer: IsNotFunction<ArrayBuffer>;
+export declare const assertArrayBuffer: AssertFunction<ArrayBuffer>;
+export declare const assertNotArrayBuffer: AssertNotFunction<ArrayBuffer>;
+export declare const assertArrayBufferPass: AssertPassFunction<ArrayBuffer>;
+export declare const assertNotArrayBufferPass: AssertNotPassFunction<ArrayBuffer>;
+export declare const isArrayBufferView: IsFunction<ArrayBufferView>;
+export declare const isNotArrayBufferView: IsNotFunction<ArrayBufferView>;
+export declare const assertArrayBufferView: AssertFunction<ArrayBufferView>;
+export declare const assertNotArrayBufferView: AssertNotFunction<ArrayBufferView>;
+export declare const assertArrayBufferViewPass: AssertPassFunction<ArrayBufferView>;
+export declare const assertNotArrayBufferViewPass: AssertNotPassFunction<ArrayBufferView>;
+export declare const isBinaryData: IsFunction<BinaryData>;
+export declare const isNotBinaryData: IsNotFunction<BinaryData>;
+export declare const assertBinaryData: AssertFunction<BinaryData>;
+export declare const assertNotBinaryData: AssertNotFunction<BinaryData>;
+export declare const assertBinaryDataPass: AssertPassFunction<BinaryData>;
+export declare const assertNotBinaryDataPass: AssertNotPassFunction<BinaryData>;
+export declare const isInt8Array: IsFunction<Int8Array>;
+export declare const isNotInt8Array: IsNotFunction<Int8Array>;
+export declare const assertInt8Array: AssertFunction<Int8Array>;
+export declare const assertNotInt8Array: AssertNotFunction<Int8Array>;
+export declare const assertInt8ArrayPass: AssertPassFunction<Int8Array>;
+export declare const assertNotInt8ArrayPass: AssertNotPassFunction<Int8Array>;
+export declare const isUint8Array: IsFunction<Uint8Array>;
+export declare const isNotUint8Array: IsNotFunction<Uint8Array>;
+export declare const assertUint8Array: AssertFunction<Uint8Array>;
+export declare const assertNotUint8Array: AssertNotFunction<Uint8Array>;
+export declare const assertUint8ArrayPass: AssertPassFunction<Uint8Array>;
+export declare const assertNotUint8ArrayPass: AssertNotPassFunction<Uint8Array>;
+export declare const isUint8ClampedArray: IsFunction<Uint8ClampedArray>;
+export declare const isNotUint8ClampedArray: IsNotFunction<Uint8ClampedArray>;
+export declare const assertUint8ClampedArray: AssertFunction<Uint8ClampedArray>;
+export declare const assertNotUint8ClampedArray: AssertNotFunction<Uint8ClampedArray>;
+export declare const assertUint8ClampedArrayPass: AssertPassFunction<Uint8ClampedArray>;
+export declare const assertNotUint8ClampedArrayPass: AssertNotPassFunction<Uint8ClampedArray>;
+export declare const isInt16Array: IsFunction<Int16Array>;
+export declare const isNotInt16Array: IsNotFunction<Int16Array>;
+export declare const assertInt16Array: AssertFunction<Int16Array>;
+export declare const assertNotInt16Array: AssertNotFunction<Int16Array>;
+export declare const assertInt16ArrayPass: AssertPassFunction<Int16Array>;
+export declare const assertNotInt16ArrayPass: AssertNotPassFunction<Int16Array>;
+export declare const isUint16Array: IsFunction<Uint16Array>;
+export declare const isNotUint16Array: IsNotFunction<Uint16Array>;
+export declare const assertUint16Array: AssertFunction<Uint16Array>;
+export declare const assertNotUint16Array: AssertNotFunction<Uint16Array>;
+export declare const assertUint16ArrayPass: AssertPassFunction<Uint16Array>;
+export declare const assertNotUint16ArrayPass: AssertNotPassFunction<Uint16Array>;
+export declare const isInt32Array: IsFunction<Int32Array>;
+export declare const isNotInt32Array: IsNotFunction<Int32Array>;
+export declare const assertInt32Array: AssertFunction<Int32Array>;
+export declare const assertNotInt32Array: AssertNotFunction<Int32Array>;
+export declare const assertInt32ArrayPass: AssertPassFunction<Int32Array>;
+export declare const assertNotInt32ArrayPass: AssertNotPassFunction<Int32Array>;
+export declare const isUint32Array: IsFunction<Uint32Array>;
+export declare const isNotUint32Array: IsNotFunction<Uint32Array>;
+export declare const assertUint32Array: AssertFunction<Uint32Array>;
+export declare const assertNotUint32Array: AssertNotFunction<Uint32Array>;
+export declare const assertUint32ArrayPass: AssertPassFunction<Uint32Array>;
+export declare const assertNotUint32ArrayPass: AssertNotPassFunction<Uint32Array>;
+export declare const isFloat32Array: IsFunction<Float32Array>;
+export declare const isNotFloat32Array: IsNotFunction<Float32Array>;
+export declare const assertFloat32Array: AssertFunction<Float32Array>;
+export declare const assertNotFloat32Array: AssertNotFunction<Float32Array>;
+export declare const assertFloat32ArrayPass: AssertPassFunction<Float32Array>;
+export declare const assertNotFloat32ArrayPass: AssertNotPassFunction<Float32Array>;
+export declare const isFloat64Array: IsFunction<Float64Array>;
+export declare const isNotFloat64Array: IsNotFunction<Float64Array>;
+export declare const assertFloat64Array: AssertFunction<Float64Array>;
+export declare const assertNotFloat64Array: AssertNotFunction<Float64Array>;
+export declare const assertFloat64ArrayPass: AssertPassFunction<Float64Array>;
+export declare const assertNotFloat64ArrayPass: AssertNotPassFunction<Float64Array>;
+export declare const isBigInt64Array: IsFunction<BigInt64Array>;
+export declare const isNotBigInt64Array: IsNotFunction<BigInt64Array>;
+export declare const assertBigInt64Array: AssertFunction<BigInt64Array>;
+export declare const assertNotBigInt64Array: AssertNotFunction<BigInt64Array>;
+export declare const assertBigInt64ArrayPass: AssertPassFunction<BigInt64Array>;
+export declare const assertNotBigInt64ArrayPass: AssertNotPassFunction<BigInt64Array>;
+export declare const isBigUint64Array: IsFunction<BigUint64Array>;
+export declare const isNotBigUint64Array: IsNotFunction<BigUint64Array>;
+export declare const assertBigUint64Array: AssertFunction<BigUint64Array>;
+export declare const assertNotBigUint64Array: AssertNotFunction<BigUint64Array>;
+export declare const assertBigUint64ArrayPass: AssertPassFunction<BigUint64Array>;
+export declare const assertNotBigUint64ArrayPass: AssertNotPassFunction<BigUint64Array>;
+export declare const isDataView: IsFunction<DataView>;
+export declare const isNotDataView: IsNotFunction<DataView>;
+export declare const assertDataView: AssertFunction<DataView>;
+export declare const assertNotDataView: AssertNotFunction<DataView>;
+export declare const assertDataViewPass: AssertPassFunction<DataView>;
+export declare const assertNotDataViewPass: AssertNotPassFunction<DataView>;
+export declare const isTypedArray: IsFunction<TypedArray>;
+export declare const isNotTypedArray: IsNotFunction<TypedArray>;
+export declare const assertTypedArray: AssertFunction<TypedArray>;
+export declare const assertNotTypedArray: AssertNotFunction<TypedArray>;
+export declare const assertTypedArrayPass: AssertPassFunction<TypedArray>;
+export declare const assertNotTypedArrayPass: AssertNotPassFunction<TypedArray>;
+export declare const isSet: IsFunction<Set<any>>;
+export declare const isNotSet: IsNotFunction<Set<any>>;
+export declare const assertSet: AssertFunction<Set<any>>;
+export declare const assertNotSet: AssertNotFunction<Set<any>>;
+export declare const assertSetPass: AssertPassFunction<Set<any>>;
+export declare const assertNotSetPass: AssertNotPassFunction<Set<any>>;
+export declare const isMap: IsFunction<Map<any, any>>;
+export declare const isNotMap: IsNotFunction<Map<any, any>>;
+export declare const assertMap: AssertFunction<Map<any, any>>;
+export declare const assertNotMap: AssertNotFunction<Map<any, any>>;
+export declare const assertMapPass: AssertPassFunction<Map<any, any>>;
+export declare const assertNotMapPass: AssertNotPassFunction<Map<any, any>>;
+export declare const isPromise: IsFunction<Promise<any>>;
+export declare const isNotPromise: IsNotFunction<Promise<any>>;
+export declare const assertPromise: AssertFunction<Promise<any>>;
+export declare const assertNotPromise: AssertNotFunction<Promise<any>>;
+export declare const assertPromisePass: AssertPassFunction<Promise<any>>;
+export declare const assertNotPromisePass: AssertNotPassFunction<Promise<any>>;
+export declare const isPromiseLike: IsFunction<PromiseLike<any>>;
+export declare const isNotPromiseLike: IsNotFunction<PromiseLike<any>>;
+export declare const assertPromiseLike: AssertFunction<PromiseLike<any>>;
+export declare const assertNotPromiseLike: AssertNotFunction<PromiseLike<any>>;
+export declare const assertPromiseLikePass: AssertPassFunction<PromiseLike<any>>;
+export declare const assertNotPromiseLikePass: AssertNotPassFunction<PromiseLike<any>>;
+export declare const isError: IsFunction<Error>;
+export declare const isNotError: IsNotFunction<Error>;
+export declare const assertError: AssertFunction<Error>;
+export declare const assertNotError: AssertNotFunction<Error>;
+export declare const assertErrorPass: AssertPassFunction<Error>;
+export declare const assertNotErrorPass: AssertNotPassFunction<Error>;
+export declare const isReadableStream: <T = any>(value: any) => value is ReadableStream<T>;
+export declare const isNotReadableStream: IsNotFunction<ReadableStream>;
+export declare const assertReadableStream: <T = any>(value: any, message?: AssertionMessage) => asserts value is ReadableStream<T>;
+export declare const assertNotReadableStream: AssertNotFunction<ReadableStream>;
+export declare const assertReadableStreamPass: <T = any>(value: any, message?: AssertionMessage) => ReadableStream<T>;
+export declare const assertNotReadableStreamPass: AssertNotPassFunction<ReadableStream>;

package/utils/z-base32.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryData } from '../types.js';
+export declare function zBase32Encode(buffer: BinaryData): string;
+export declare function zBase32Decode(input: string): Uint8Array;

package/document-management/models/service-models/categories-and-types.view-model.js

@@ -1,5 +0,0 @@
-import { DocumentCategory } from '../document-category.model.js';
-export class DocumentCategoryView extends DocumentCategory {
-    children;
-    types;
-}

package/document-management/models/service-models/document-folders.view-model.js

@@ -1,32 +0,0 @@
-import { isNotNull } from '../../../utils/type-guards.js';
-export function getDocumentManagementFolders(data, options = {}) {
-    const allFolder = (options.includeAllFolder == true)
-        ? []
-        : [{
-                id: 'all',
-                type: 'virtual',
-                label: 'Alle',
-                documents: data.documents,
-                subFolders: [],
-            }];
-    function getCategoryFolder(category) {
-        const subFolders = category.children.map(getCategoryFolder).filter(isNotNull);
-        const documents = data.documents.filter((document) => document.type?.category.id == category.id);
-        const categoryFolder = {
-            id: category.id,
-            type: 'category',
-            label: category.label,
-            subFolders,
-            documents: (options.includeChildCategoryDocuments == true) ? [...documents, ...subFolders.flatMap((folder) => folder.documents)] : documents,
-        };
-        if ((categoryFolder.documents.length + categoryFolder.subFolders.length) == 0) {
-            return null;
-        }
-        return categoryFolder;
-    }
-    const rootCategoryFolders = data.rootCategories.map(getCategoryFolder).filter(isNotNull);
-    return [...allFolder, ...rootCategoryFolders];
-}
-export function getFlatFolders(folders) {
-    return [...folders, ...folders.flatMap((folder) => getFlatFolders(folder.subFolders))];
-}

package/document-management/models/service-models/document-management.view-model.js

@@ -1,127 +0,0 @@
-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 { Array, Enumeration, Property, StringProperty, Union } from '../../../schema/index.js';
-import { DocumentCategory } from '../document-category.model.js';
-import { DocumentCollectionAssignment } from '../document-collection-assignment.model.js';
-import { DocumentCollection } from '../document-collection.model.js';
-import { DocumentFile } from '../document-file.model.js';
-import { DocumentPropertyDataType } from '../document-property.model.js';
-import { DocumentRequest } from '../document-request.model.js';
-import { DocumentType } from '../document-type.model.js';
-import { DocumentValidationExecution } from '../document-validation-execution.model.js';
-import { DocumentWorkflow } from '../document-workflow.model.js';
-import { Document } from '../document.model.js';
-export class DocumentCollectionView extends DocumentCollection {
-    name;
-    group;
-}
-__decorate([
-    StringProperty({ nullable: true }),
-    __metadata("design:type", String)
-], DocumentCollectionView.prototype, "name", void 0);
-__decorate([
-    StringProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentCollectionView.prototype, "group", void 0);
-export class DocumentPropertyValueView {
-    documentId;
-    propertyId;
-    label;
-    dataType;
-    value;
-}
-__decorate([
-    StringProperty(),
-    __metadata("design:type", String)
-], DocumentPropertyValueView.prototype, "documentId", void 0);
-__decorate([
-    StringProperty(),
-    __metadata("design:type", String)
-], DocumentPropertyValueView.prototype, "propertyId", void 0);
-__decorate([
-    StringProperty(),
-    __metadata("design:type", String)
-], DocumentPropertyValueView.prototype, "label", void 0);
-__decorate([
-    Enumeration(DocumentPropertyDataType),
-    __metadata("design:type", String)
-], DocumentPropertyValueView.prototype, "dataType", void 0);
-__decorate([
-    Union(String, Number, Boolean, { nullable: true }),
-    __metadata("design:type", Object)
-], DocumentPropertyValueView.prototype, "value", void 0);
-export class DocumentView extends Document {
-    collectionAssignments;
-    properties;
-    /** available as long as the document is neither approved nor rejected */
-    currentWorkflow;
-    validations;
-}
-__decorate([
-    Array(DocumentCollectionAssignment),
-    __metadata("design:type", Array)
-], DocumentView.prototype, "collectionAssignments", void 0);
-__decorate([
-    Array(DocumentPropertyValueView),
-    __metadata("design:type", Array)
-], DocumentView.prototype, "properties", void 0);
-__decorate([
-    Property(DocumentWorkflow, { nullable: true }),
-    __metadata("design:type", Object)
-], DocumentView.prototype, "currentWorkflow", void 0);
-__decorate([
-    Array(DocumentValidationExecution, { nullable: true }),
-    __metadata("design:type", Object)
-], DocumentView.prototype, "validations", void 0);
-export class DocumentRequestView extends DocumentRequest {
-    collectionIds;
-    /** current approval-pending or approved document */
-    document;
-}
-__decorate([
-    Array(String),
-    __metadata("design:type", Array)
-], DocumentRequestView.prototype, "collectionIds", void 0);
-__decorate([
-    Property(Document, { nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestView.prototype, "document", void 0);
-export class DocumentManagementData {
-    collections;
-    documents;
-    requests;
-    files;
-    categories;
-    types;
-}
-__decorate([
-    Array(DocumentCollectionView),
-    __metadata("design:type", Array)
-], DocumentManagementData.prototype, "collections", void 0);
-__decorate([
-    Array(DocumentView),
-    __metadata("design:type", Array)
-], DocumentManagementData.prototype, "documents", void 0);
-__decorate([
-    Array(DocumentRequestView),
-    __metadata("design:type", Array)
-], DocumentManagementData.prototype, "requests", void 0);
-__decorate([
-    Array(DocumentFile),
-    __metadata("design:type", Array)
-], DocumentManagementData.prototype, "files", void 0);
-__decorate([
-    Array(DocumentCategory),
-    __metadata("design:type", Array)
-], DocumentManagementData.prototype, "categories", void 0);
-__decorate([
-    Array(DocumentType),
-    __metadata("design:type", Array)
-], DocumentManagementData.prototype, "types", void 0);

package/document-management/models/service-models/document-requests-template.view-model.js

@@ -1,26 +0,0 @@
-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 { Array } from '../../../schema/index.js';
-import { DocumentRequestTemplate } from '../document-request-template.js';
-import { DocumentRequestsTemplate } from '../document-requests-template.js';
-export class DocumentRequestsTemplateView extends DocumentRequestsTemplate {
-    requestTemplates;
-}
-__decorate([
-    Array(DocumentRequestTemplate),
-    __metadata("design:type", Array)
-], DocumentRequestsTemplateView.prototype, "requestTemplates", void 0);
-export class DocumentRequestsTemplateData {
-    templates;
-}
-__decorate([
-    Array(DocumentRequestsTemplateView),
-    __metadata("design:type", Array)
-], DocumentRequestsTemplateData.prototype, "templates", void 0);

package/document-management/models/service-models/document.service-model.js

@@ -1,57 +0,0 @@
-import { EntityMetadata } from '../../../orm/entity.js';
-import { array, assign, boolean, enumeration, never, nullable, number, object, omit, oneOrMany, optional, partial, pick, string, union } from '../../../schema/index.js';
-import { DocumentAssignmentTarget } from '../document-assignment-task.model.js';
-import { DocumentCategory } from '../document-category.model.js';
-import { DocumentCollectionAssignment } from '../document-collection-assignment.model.js';
-import { DocumentCollection } from '../document-collection.model.js';
-import { DocumentFile } from '../document-file.model.js';
-import { DocumentPropertyValue } from '../document-property-value.model.js';
-import { DocumentProperty } from '../document-property.model.js';
-import { DocumentRequestTemplate } from '../document-request-template.js';
-import { DocumentRequest } from '../document-request.model.js';
-import { DocumentRequestsTemplate } from '../document-requests-template.js';
-import { DocumentTypeProperty } from '../document-type-property.model.js';
-import { DocumentType } from '../document-type.model.js';
-import { Document } from '../document.model.js';
-export const metadataParameterSchema = optional(partial(pick(EntityMetadata, 'attributes')));
-export const metadataParameterObjectSchema = object({ metadata: metadataParameterSchema });
-export const setDocumentPropertyParametersSchema = assign(pick(DocumentPropertyValue, ['propertyId']), object({ value: union(string(), number(), boolean(), nullable(never())) }), metadataParameterObjectSchema);
-export const createDocumentParametersSchema = assign(pick(Document, ['typeId', 'title', 'subtitle', 'date', 'summary', 'tags', 'approval', 'comment', 'createUserId']), pick(DocumentFile, ['originalFileName']), object({
-    assignment: union(object({ collections: oneOrMany(string(), { minimum: 1 }) }), object({ request: string() }), object({
-        automatic: object({
-            /** collection ids to assign in */
-            scope: oneOrMany(string(), { minimum: 1 }),
-            target: enumeration(DocumentAssignmentTarget),
-        }),
-    })),
-    properties: optional(array(setDocumentPropertyParametersSchema)),
-}), metadataParameterObjectSchema);
-export const updateDocumentParametersSchema = assign(pick(Document, ['id']), partial(omit(Document, ['id', 'metadata'])), object({ properties: optional(array(setDocumentPropertyParametersSchema)) }), metadataParameterObjectSchema);
-export const approveDocumentParametersSchema = assign(pick(Document, ['id', 'comment']), metadataParameterObjectSchema);
-export const rejectDocumentParametersSchema = assign(pick(Document, ['id', 'comment']), metadataParameterObjectSchema);
-export const createDocumentRequestsTemplateParametersSchema = assign(pick(DocumentRequestsTemplate, ['label', 'description']), metadataParameterObjectSchema);
-export const updateDocumentRequestsTemplateParametersSchema = assign(pick(DocumentRequestsTemplate, ['id']), partial(omit(DocumentRequestsTemplate, ['id', 'metadata'])), metadataParameterObjectSchema);
-export const applyDocumentRequestsTemplateParametersSchema = assign(pick(DocumentRequestsTemplate, ['id']), object({ collectionIds: array(string()) }), metadataParameterObjectSchema);
-export const deleteDocumentRequestsTemplateParametersSchema = assign(pick(DocumentRequestsTemplate, ['id']), metadataParameterObjectSchema);
-export const createDocumentRequestTemplateParametersSchema = assign(pick(DocumentRequestTemplate, ['requestsTemplateId', 'typeId', 'comment']), metadataParameterObjectSchema);
-export const updateDocumentRequestTemplateParametersSchema = assign(pick(DocumentRequestTemplate, ['id']), partial(omit(DocumentRequestTemplate, ['id', 'requestsTemplateId', 'metadata'])), metadataParameterObjectSchema);
-export const deleteDocumentRequestTemplateParametersSchema = assign(pick(DocumentRequestTemplate, ['id']), metadataParameterObjectSchema);
-export const createDocumentRequestParametersSchema = assign(pick(DocumentRequest, ['typeId', 'comment']), object({ collectionIds: array(string()) }), metadataParameterObjectSchema);
-export const updateDocumentRequestParametersSchema = assign(pick(DocumentRequest, ['id']), partial(pick(DocumentRequest, ['typeId', 'comment'])), metadataParameterObjectSchema);
-export const deleteDocumentRequestParametersSchema = assign(pick(DocumentRequest, ['id']), metadataParameterObjectSchema);
-export const loadDataParametersSchema = object({ collectionIds: oneOrMany(string()) });
-export const createCollectionParametersSchema = assign(pick(DocumentCollection, ['parentId']), metadataParameterObjectSchema);
-export const setDocumentPropertiesParametersSchema = object({
-    documentId: string(),
-    properties: array(setDocumentPropertyParametersSchema),
-});
-export const createDocumentCategoryParametersSchema = assign(pick(DocumentCategory, ['parentId', 'label']), metadataParameterObjectSchema);
-export const createDocumentTypeParametersSchema = assign(pick(DocumentType, ['categoryId', 'label']), metadataParameterObjectSchema);
-export const approveDocumentRequestParametersSchema = assign(pick(DocumentRequest, ['id', 'comment']), object({
-    documentMetadata: metadataParameterSchema,
-    requestMetadata: metadataParameterSchema,
-}));
-export const rejectDocumentRequestParametersSchema = assign(pick(DocumentRequest, ['id', 'comment']), metadataParameterObjectSchema);
-export const createDocumentPropertyParametersSchema = assign(pick(DocumentProperty, ['label', 'dataType']), metadataParameterObjectSchema);
-export const assignPropertyToTypeParametersSchema = assign(pick(DocumentTypeProperty, ['typeId', 'propertyId']), metadataParameterObjectSchema);
-export const addOrArchiveDocumentToOrFromCollectionParametersSchema = assign(pick(DocumentCollectionAssignment, ['collectionId', 'documentId']), metadataParameterObjectSchema);