@tstdl/base 0.92.144 → 0.92.147

package/utils/format-error.d.ts

@@ -1,4 +1,4 @@
-import type { UndefinableJson } from '../types.js';
+import type { UndefinableJson } from '../types/index.js';
 export type FormatErrorOptions = {
     /**
      * Include error name in message

package/utils/function/class.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor } from '../../types.js';
+import type { AbstractConstructor } from '../../types/index.js';
 declare class EmptyClass {
 }
 export declare function getClassOfName(name: string): typeof EmptyClass;

package/utils/function/memoize.d.ts

@@ -1,4 +1,4 @@
-import type { Constructor } from '../../types.js';
+import type { Constructor } from '../../types/index.js';
 export type MemoizeOptions = {
     /** Use WeakMap instead of Map for caching. Can be used with object parameters only */
     weak?: boolean;

package/utils/helpers.d.ts

@@ -1,4 +1,4 @@
-import type { DeepArray, Record } from '../types.js';
+import type { DeepArray, Record } from '../types/index.js';
 /**
  * Create an structured clone of an value using Notification if available, otherwise history state (may alters history)
  *

package/utils/helpers.js

@@ -1,5 +1,5 @@
-import { supportsNotification } from '../supports.js';
 import { DetailsError } from '../errors/details.error.js';
+import { supportsNotification } from '../supports.js';
 import { decycle } from './object/decycle.js';
 /**
  * Create an structured clone of an value using Notification if available, otherwise history state (may alters history)
@@ -64,7 +64,7 @@ export function parseFirstAndFamilyName(name) {
     const firstName = parts.map((part) => part.trim()).join(' ');
     return {
         firstName: firstName.length > 0 ? firstName : undefined,
-        familyName: familyName.length > 0 ? familyName : undefined
+        familyName: familyName.length > 0 ? familyName : undefined,
     };
 }
 export function iif(condition, trueFn, falseFn) {

package/utils/jwt.d.ts

@@ -1,11 +1,11 @@
-import type { OneOrMany, StringMap } from '../types.js';
+import type { OneOrMany, Record } from '../types/index.js';
 import type { Key } from './cryptography.js';
 export type JwtTokenAlgorithm = 'HS256' | 'HS384' | 'HS512';
-export type JwtTokenHeader<T extends StringMap = StringMap> = {
+export type JwtTokenHeader<T extends Record<string> = Record<string>> = {
     alg: JwtTokenAlgorithm;
     typ: 'JWT';
 } & T;
-export type JwtToken<TPayload = StringMap, THeader extends JwtTokenHeader = JwtTokenHeader> = {
+export type JwtToken<TPayload = Record<string>, THeader extends JwtTokenHeader = JwtTokenHeader> = {
     readonly header: THeader;
     readonly payload: TPayload;
 };

package/utils/merge.d.ts

@@ -1,5 +1,5 @@
 import type { IsEqual, MergeDeep, MergeDeepOptions as TypeFestMergeDeepOptions } from 'type-fest';
-import type { If, Merge, Record, TypedOmit } from '../types.js';
+import type { If, Merge, Record, TypedOmit } from '../types/index.js';
 type BaseType = Record | any[] | Map<any, any> | Set<any>;
 export declare function merge<A extends BaseType, B extends BaseType>(a: A | undefined, b: B | undefined): A extends (infer T)[] ? B extends (infer U)[] ? (T | U)[] : never : A extends Map<infer K, infer V> ? B extends Map<infer K2, infer V2> ? Map<K | K2, V | V2> : never : A extends Set<infer T> ? B extends Set<infer U> ? Set<T | U> : never : A extends Record ? B extends Record ? Merge<A, B> : never : never;
 export type MergeDeepOptions = TypedOmit<TypeFestMergeDeepOptions, 'arrayMergeMode'> & {

package/utils/middleware.js

@@ -32,11 +32,11 @@ export function composeAsyncMiddleware(middlewares, options = {}) {
                 if ((index < currentIndex) && (options.allowMultipleNextCalls != true)) {
                     throw new Error('next() called multiple times');
                 }
-                return dispatch(index + 1);
+                await dispatch(index + 1);
             }
-            return middleware(context, next); // eslint-disable-line consistent-return
+            await middleware(context, next);
         }
-        return dispatch(0);
+        await dispatch(0);
     }
     return composedMiddleware;
 }

package/utils/object/decycle.d.ts

@@ -1,4 +1,4 @@
-import type { Record } from '../../types.js';
+import type { Record } from '../../types/index.js';
 export type Decycled<T> = {
     __type: T;
 } & Record<string>;

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

@@ -1,4 +1,4 @@
-import type { AbstractConstructor } from '../../types.js';
+import type { AbstractConstructor } from '../../types/index.js';
 declare const isForwardRef: unique symbol;
 export type ForwardRefTypeHint = 'object' | 'function' | AbstractConstructor;
 export type ForwardRefOptions<T extends object = object> = {

package/utils/object/lazy-property.d.ts

@@ -1,4 +1,4 @@
-import type { Function, IfUnknown } from '../../types.js';
+import type { Function, IfUnknown } from '../../types/index.js';
 declare const lazyObjectValueSymbol: unique symbol;
 export type LazyPropertyInitializer<T, K extends keyof T> = (this: T, key: K) => T[K];
 export type LazyPropertyObjectDefinition<T extends object, P extends keyof T> = LazyPropertyDescriptor & {

package/utils/object/object.d.ts

@@ -1,5 +1,5 @@
 import { type JsonPathInput } from '../../json-path/json-path.js';
-import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject, UnionToIntersection } from '../../types.js';
+import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject, UnionToIntersection } from '../../types/index.js';
 export declare function hasOwnProperty<T extends Record, K extends keyof UnionToIntersection<T>>(obj: T, key: K): obj is Extract<T, Partial<Record<K>>>;
 export declare function hasOwnProperty<T extends Record>(obj: T, key: keyof T): boolean;
 /**

package/utils/object/property-name.d.ts

@@ -1,4 +1,4 @@
-import type { DeepFlatten, DeepNonNullable, Record } from '../../types.js';
+import type { DeepFlatten, DeepNonNullable, Record } from '../../types/index.js';
 export declare const propertyName: unique symbol;
 export declare const cast: unique symbol;
 export type PropertyName = {

package/utils/patch-worker.d.ts

@@ -1,5 +1,5 @@
 import { type Observable } from 'rxjs';
-import type { Record, StringMap } from '../types.js';
+import type { Record, StringMap } from '../types/index.js';
 export type PatchWorkerOptions<T extends StringMap> = {
     debounceTime?: number;
     retryDelay?: number;

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

@@ -1,5 +1,5 @@
 import { type Signal, type ToSignalOptions } from '../signals/api.js';
-import type { ReactiveValue } from '../types.js';
+import type { ReactiveValue } from '../types/index.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> & {

package/utils/reflection.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata/lite';
-import type { Type } from '../types.js';
+import type { Type } from '../types/index.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;

package/utils/repl.d.ts

@@ -1,5 +1,5 @@
 import type { ReplOptions } from 'node:repl';
-import type { Record } from '../types.js';
+import type { Record } from '../types/index.js';
 /**
  * Starts an interactive (repl) session (node only)
  * @param context context to set the repl context to

package/utils/singleton.d.ts

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

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

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

package/utils/type/extends.d.ts

@@ -1,3 +1,3 @@
-import type { AbstractConstructor } from '../../types.js';
+import type { AbstractConstructor } from '../../types/index.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

@@ -1,4 +1,4 @@
-import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, Type, TypedArray } from '../types.js';
+import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, Type, TypedArray } from '../types/index.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>;

package/utils/url-builder.d.ts

@@ -1,4 +1,4 @@
-import type { UndefinableJsonObject, UndefinableJsonPrimitive } from '../types.js';
+import type { UndefinableJsonObject, UndefinableJsonPrimitive } from '../types/index.js';
 export type UrlBuilderParameterValue = UndefinableJsonPrimitive;
 export type UrlBuilderParameters = UndefinableJsonObject;
 export type UrlBuilderOptions = {

package/utils/z-base32.d.ts

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

package/module/utils.d.ts

@@ -1,4 +0,0 @@
-import type { Logger } from '../logger/index.js';
-import type { Module } from './module.js';
-export declare function runModules(modules: Module[], logger?: Logger): Promise<void>;
-export declare function stopModules(modules: Module[], logger?: Logger): Promise<void>;

package/module/utils.js

@@ -1,21 +0,0 @@
-export async function runModules(modules, logger) {
-    const promises = modules.map(async (module) => {
-        if (logger != undefined) {
-            logger.verbose(`starting module ${module.name}`);
-        }
-        await module.run();
-    });
-    await Promise.all(promises);
-}
-export async function stopModules(modules, logger) {
-    const promises = modules.map(async (module) => {
-        if (logger != undefined) {
-            logger.verbose(`stopping module ${module.name}`);
-        }
-        await module.stop();
-        if (logger != undefined) {
-            logger.verbose(`stopped module ${module.name}`);
-        }
-    });
-    await Promise.all(promises);
-}