@powerlines/deepkit 0.7.3 → 0.7.5

package/dist/types-Bb6lL3KL.d.cts

@@ -0,0 +1,511 @@
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/cjs/src/core.d.ts
+/**
+ * Makes sure the error once printed using console.log contains the actual class name.
+ *
+ * @example
+ * ```
+ * class MyApiError extends CustomerError {}
+ *
+ * throw MyApiError() // prints MyApiError instead of simply "Error".
+ * ```
+ *
+ * @public
+ */
+declare class CustomError extends Error {
+  name: string;
+  constructor(...args: any[]);
+}
+interface CustomError {
+  cause?: unknown;
+}
+/**
+ * @public
+ */
+interface ClassType<T = any> {
+  new (...args: any[]): T;
+}
+/**
+ * @public
+ */
+type AbstractClassType<T = any> = abstract new (...args: any[]) => T;
+type ExtractClassType<T> = T extends AbstractClassType<infer K> ? K : never;
+/**
+ * Returns the class name either of the class definition or of the class of an instance.
+ *
+ * Note when code is minimized/uglified this output will change. You should disable in your compile the
+ * className modification.
+ *
+ * @example
+ * ```typescript
+ * class User {}
+ *
+ * expect(getClassName(User)).toBe('User');
+ * expect(getClassName(new User())).toBe('User');
+ * ```
+ *
+ * @public
+ */
+declare function getClassName<T>(classTypeOrInstance: ClassType<T> | Object): string;
+/**
+ * Same as getClassName but appends the propertyName.
+ * @public
+ */
+declare function getClassPropertyName<T>(classType: ClassType<T> | Object, propertyName: string): string;
+/**
+ * @public
+ */
+declare function applyDefaults<T>(classType: ClassType<T>, target: {
+  [k: string]: any;
+}): T;
+/**
+ * Tries to identify the object by normalised result of Object.toString(obj).
+ */
+declare function identifyType(obj: any): string;
+/**
+ * Returns true if the given obj is a plain object, and no class instance.
+ *
+ * isPlainObject(\{\}) === true
+ * isPlainObject(new ClassXY) === false
+ *
+ * @public
+ */
+declare function isPlainObject(obj: any): obj is object;
+/**
+ * Returns the ClassType for a given instance.
+ */
+declare function getClassTypeFromInstance<T>(target: T): ClassType<T>;
+/**
+ * Returns true when target is a class instance.
+ */
+declare function isClassInstance(target: any): boolean;
+/**
+ * Returns a human-readable string representation from the given value.
+ */
+declare function stringifyValueWithType(value: any, depth?: number): string;
+/**
+ * Changes the class of a given instance and returns the new object.
+ *
+ * @example
+ * ```typescript
+ *
+ *  class Model1 {
+ *    id: number = 0;
+ *  }
+ *
+ *  class Model2 {
+ *    id: number = 0;
+ *  }
+ *
+ *  const model1 = new Model1();
+ *  const model2 = changeClass(model1, Model2);
+ *  model2 instanceof Model2; //true
+ * ```
+ */
+declare function changeClass<T>(value: object, newClass: ClassType<T>): T;
+declare function prettyPrintObject(object: object, depth?: number): string;
+/**
+ * Returns true if given obj is a function.
+ *
+ * @public
+ */
+declare function isFunction(obj: any): obj is Function;
+declare const AsyncFunction: {
+  new (...args: string[]): Function;
+};
+/**
+ * Returns true if given obj is a async function.
+ *
+ * @public
+ */
+declare function isAsyncFunction(obj: any): obj is (...args: any[]) => Promise<any>;
+/**
+ * Returns true if given obj is a promise like object.
+ *
+ * Note: There's not way to check if it's actually a Promise using instanceof since
+ * there are a lot of different implementations around.
+ *
+ * @public
+ */
+declare function isPromise<T>(obj: any | Promise<T>): obj is Promise<T>;
+/**
+ * Returns true if given obj is a ES6 class (ES5 fake classes are not supported).
+ *
+ * @public
+ */
+declare function isClass(obj: any): obj is AbstractClassType;
+declare function isGlobalClass(obj: any): obj is AbstractClassType;
+/**
+ * Returns true for real objects: object literals ({}) or class instances (new MyClass).
+ *
+ * @public
+ */
+declare function isObject(obj: any): obj is {
+  [key: string]: any;
+};
+/**
+ * Returns true if given obj is a plain object, and no Date, Array, Map, Set, etc.
+ *
+ * This is different to isObject and used in the type system to differentiate
+ * between JS objects in general and what we define as ReflectionKind.objectLiteral.
+ * Since we have Date, Set, Map, etc. in the type system, we need to differentiate
+ * between them and all other object literals.
+ */
+declare function isObjectLiteral(obj: any): obj is {
+  [key: string]: any;
+};
+/**
+ * @public
+ */
+declare const isArray: (obj: any) => obj is any[];
+/**
+ * @public
+ */
+declare function isNull(obj: any): obj is null;
+/**
+ * @public
+ */
+declare function isUndefined(obj: any): obj is undefined;
+/**
+ * Checks if obj is not null and not undefined.
+ *
+ * @public
+ */
+declare function isSet(obj: any): boolean;
+/**
+ * @public
+ */
+declare function isNumber(obj: any): obj is number;
+/**
+ * Returns true if given value is strictly a numeric string value (or a number).
+ *
+ * ```typescript
+ * isNumeric(12); //true
+ * isNumeric('12'); //true
+ * isNumeric('12.3'); //true
+ * isNumeric('12.3 '); //false
+ * isNumeric('12px'); //false
+ * ```
+ * @public
+ */
+declare function isNumeric(s: string | number): boolean;
+declare const isInteger: (obj: any) => obj is number;
+/**
+ * @public
+ */
+declare function isString(obj: any): obj is string;
+/**
+ * @public
+ */
+declare function indexOf<T>(array: T[], item: T): number;
+/**
+ * @public
+ */
+declare function sleep(seconds: number): Promise<void>;
+/**
+ * Creates a shallow copy of given array.
+ *
+ * @public
+ */
+declare function copy<T>(v: T[]): T[];
+/**
+ * Checks whether given array or object is empty (no keys). If given object is falsy, returns false.
+ *
+ * @public
+ */
+declare function empty<T>(value?: T[] | object | {}): boolean;
+/**
+ * Returns the size of given array or object.
+ *
+ * @public
+ */
+declare function size<T>(array: T[] | {
+  [key: string]: T;
+}): number;
+/**
+ * Returns the first key of a given object.
+ *
+ * @public
+ */
+declare function firstKey(v: {
+  [key: string]: any;
+} | object): string | undefined;
+/**
+ * Returns the last key of a given object.
+ *
+ * @public
+ */
+declare function lastKey(v: {
+  [key: string]: any;
+} | object): string | undefined;
+/**
+ * Returns the first value of given array or object.
+ *
+ * @public
+ */
+declare function first<T>(v: {
+  [key: string]: T;
+} | T[]): T | undefined;
+/**
+ * Returns the last value of given array or object.
+ *
+ * @public
+ */
+declare function last<T>(v: {
+  [key: string]: T;
+} | T[]): T | undefined;
+/**
+ * Returns the average of a number array.
+ *
+ * @public
+ */
+declare function average(array: number[]): number;
+/**
+ * @public
+ */
+declare function prependObjectKeys(o: {
+  [k: string]: any;
+}, prependText: string): {
+  [k: string]: any;
+};
+/**
+ * @public
+ */
+declare function appendObject(origin: {
+  [k: string]: any;
+}, extend: {
+  [k: string]: any;
+}, prependKeyName?: string): void;
+/**
+ * A better alternative to "new Promise()" that supports error handling and maintains the stack trace for Error.stack.
+ *
+ * When you use `new Promise()` you need to wrap your code inside a try-catch to call `reject` on error.
+ * asyncOperation() does this automatically.
+ *
+ * When you use `new Promise()` you will lose the stack trace when `reject(new Error())` is called.
+ * asyncOperation() makes sure the error stack trace is the correct one.
+ *
+ * @example
+ * ```typescript
+ * await asyncOperation(async (resolve, reject) => {
+ *     await doSomething(); //if this fails, reject() will automatically be called
+ *     stream.on('data', (data) => {
+ *         resolve(data); //at some point you MUST call resolve(data)
+ *     });
+ * });
+ * ```
+ *
+ * @public
+ * @reflection never
+ */
+declare function asyncOperation<T>(executor: (resolve: (value: T) => void, reject: (error: any) => void) => void | Promise<void>): Promise<T>;
+/**
+ * When an API is called that returns a promise that loses the stack trace on error, you can use fixAsyncOperation().
+ *
+ * ```typescript
+ * cons storage = new BrokenPromiseStorage();
+ * const files = await fixAsyncOperation(storage.files('/'));
+ * ```
+ */
+declare function fixAsyncOperation<T>(promise: Promise<T>): Promise<T>;
+/**
+ * @public
+ */
+declare function mergePromiseStack<T>(promise: Promise<T>, stack?: string): Promise<T>;
+/**
+ * @beta
+ */
+declare function createStack(removeCallee?: boolean): string;
+/**
+ * @beta
+ */
+declare function mergeStack(error: Error, stack: string): void;
+/**
+ * Makes sure the given value is an error. If it's not an error, it creates a new error with the given value as message.
+ */
+declare function ensureError(error?: any, classType?: ClassType): Error;
+declare function collectForMicrotask<T>(callback: (args: T[]) => void): (arg: T) => void;
+/**
+ * Returns the current time as seconds.
+ *
+ * @public
+ */
+declare function time(): number;
+/**
+ * @public
+ */
+declare function getPathValue(bag: {
+  [field: string]: any;
+}, parameterPath: string, defaultValue?: any): any;
+/**
+ * @public
+ */
+declare function setPathValue(bag: object, parameterPath: string, value: any): void;
+/**
+ * @public
+ */
+declare function deletePathValue(bag: object, parameterPath: string): void;
+/**
+ * Returns the human-readable byte representation.
+ *
+ * @public
+ */
+declare function humanBytes(bytes: number, si?: boolean): string;
+/**
+ * Returns the number of properties on `obj`. This is 20x faster than Object.keys(obj).length.
+ */
+declare function getObjectKeysSize(obj: object): number;
+declare function isConstructable(fn: any): boolean;
+declare function isPrototypeOfBase(prototype: AbstractClassType | undefined, base: ClassType): boolean;
+declare function getParentClass(classType: ClassType): ClassType | undefined;
+declare function getInheritanceChain(classType: ClassType): ClassType[];
+declare function inDebugMode(): boolean;
+/**
+ * Create a new class with the given name.
+ * This is currently the only know way to make it workable in browsers too.
+ */
+declare function createDynamicClass(name: string, base?: ClassType): ClassType;
+declare function isIterable(value: any): boolean;
+declare function iterableSize(value: Array<unknown> | Set<unknown> | Map<unknown, unknown>): number;
+/**
+ * Returns __filename, works in both cjs and esm.
+ */
+declare function getCurrentFileName(): string;
+/**
+ * Escape special characters in a regex string, so it can be used as a literal string.
+ */
+declare function escapeRegExp(string: string): string;
+declare function hasProperty(object: any, property: any): boolean;
+/**
+ * Returns an iterator of numbers from start (inclusive) to stop (exclusive) by step.
+ */
+declare function range(startOrLength: number, stop?: number, step?: number): IterableIterator<number>;
+/**
+ * Returns an array of numbers from start (inclusive) to stop (exclusive) by step.
+ *
+ * Works the same as python's range function.
+ */
+declare function rangeArray(startOrLength: number, stop?: number, step?: number): number[];
+/**
+ * Returns a combined array of the given arrays.
+ *
+ * Works the same as python's zip function.
+ */
+declare function zip<T extends (readonly unknown[])[]>(...args: T): { [K in keyof T]: T[K] extends (infer V)[] ? V : never }[];
+/**
+ * Forwards the runtime type arguments from function x to function y.
+ * This is necessary when a generic function is overridden and forwarded to something else.
+ *
+ * ```typescript
+ * let generic = <T>(type?: ReceiveType<T>) => undefined;
+ *
+ * let forwarded<T> = () => {
+ *     forwardTypeArguments(forwarded, generic); //all type arguments are forwarded to generic()
+ *     generic(); //call as usual
+ * }
+ *
+ * forwarded<any>(); //generic receives any in runtime.
+ * ```
+ *
+ * Note that generic.bind(this) will not work, as bind() creates a new function and forwarded type arguments can not
+ * reach the original function anymore.
+ *
+ * ```typescript
+ * let forwarded<T> = () => {
+ *     const bound = generic.bind(this);
+ *     forwardTypeArguments(forwarded, bound); //can not be forwarded anymore
+ *     bound(); //fails
+ * }
+ * ```
+ *
+ *  This is a limitation of JavaScript. In this case you have to manually forward type arguments.
+ *
+ *  ```typescript
+ *  let forwarded<T> = (type?: ReceiveType<T>) => {
+ *     const bound = generic.bind(this);
+ *     bound(type);
+ *  }
+ *  ```
+ */
+declare function forwardTypeArguments(x: any, y: any): void;
+declare function formatError(error: any, withStack?: boolean): string;
+/**
+ * Asserts that the given object is an instance of the given class.
+ */
+declare function assertInstanceOf<T>(object: any, constructor: {
+  new (...args: any[]): T;
+}): asserts object is T;
+/**
+ * Asserts that the given value is defined (not null and not undefined).
+ */
+declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
+declare type __ΩCustomError = any[];
+declare type __ΩClassType = any[];
+declare type __ΩAbstractClassType = any[];
+declare type __ΩExtractClassType = any[];
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/cjs/src/compiler.d.ts
+declare class CompilerContext {
+  readonly context: Map<string, any>;
+  protected constVariables: Map<any, string>;
+  maxReservedVariable: number;
+  protected reservedNames: Set<string>;
+  protected variableContext: {
+    [name: string]: any;
+  };
+  /**
+   * Code that is executed in the context, but before the actual function is generated.
+   * This helps for example to initialize dynamically some context variables.
+   */
+  preCode: string;
+  initialiseVariables: string[];
+  config: {
+    indent: boolean;
+  };
+  constructor(config?: Partial<CompilerContext['config']>);
+  reserveName(name: string): string;
+  set(values: {
+    [name: string]: any;
+  }): void;
+  /**
+   * Returns always the same variable name for the same value.
+   * The variable name should not be set afterwards.
+   */
+  reserveConst(value: any, name?: string): string;
+  reserveVariable(name?: string, value?: any): string;
+  raw(functionCode: string): Function;
+  protected format(code: string): string;
+  build(functionCode: string, ...args: string[]): any;
+  buildAsync(functionCode: string, ...args: string[]): Function;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/cjs/src/types.d.ts
+/**
+ * Type to use for custom type annotations.
+ *
+ * Adds runtime meta information to a type without influencing the type itself.
+ * This is like an intrinsic type, but only for runtime.
+ *
+ * ```typescript
+ * import { TypeAnnotation } from '@deepkit/core';
+ * import { typeAnnotation } from '@deepkit/type';
+ *
+ * type PrimaryKey = TypeAnnotation<'primaryKey'>;
+ * type UserId = string & PrimaryKey;
+ *
+ * const type = typeOf<UserId>();
+ * const metaData = typeAnnotation.getType(type, 'primaryKey');
+ * ```
+ *
+ * Runtime type is `{ __meta?: never & [T, Options] };`
+ *
+ * @intrinsic
+ */
+type TypeAnnotation<T extends string, Options = never> = unknown;
+type InjectMeta<T = never> = TypeAnnotation<'inject', T>;
+type Inject<Type, Token = never> = Type & InjectMeta<Token>;
+declare type __ΩTypeAnnotation = any[];
+declare type __ΩInjectMeta = any[];
+declare type __ΩInject = any[];
+//#endregion
+export { isClassInstance as $, ensureError as A, zip as At, getCurrentFileName as B, changeClass as C, range as Ct, createStack as D, sleep as Dt, createDynamicClass as E, size as Et, formatError as F, hasProperty as G, getObjectKeysSize as H, forwardTypeArguments as I, inDebugMode as J, humanBytes as K, getClassName as L, first as M, firstKey as N, deletePathValue as O, stringifyValueWithType as Ot, fixAsyncOperation as P, isClass as Q, getClassPropertyName as R, average as S, prettyPrintObject as St, copy as T, setPathValue as Tt, getParentClass as U, getInheritanceChain as V, getPathValue as W, isArray as X, indexOf as Y, isAsyncFunction as Z, appendObject as _, last as _t, __ΩInjectMeta as a, isNull as at, assertInstanceOf as b, mergeStack as bt, AbstractClassType as c, isObject as ct, CustomError as d, isPromise as dt, isConstructable as et, ExtractClassType as f, isPrototypeOfBase as ft, __ΩExtractClassType as g, iterableSize as gt, __ΩCustomError as h, isUndefined as ht, __ΩInject as i, isIterable as it, escapeRegExp as j, empty as k, time as kt, AsyncFunction as l, isObjectLiteral as lt, __ΩClassType as m, isString as mt, InjectMeta as n, isGlobalClass as nt, __ΩTypeAnnotation as o, isNumber as ot, __ΩAbstractClassType as p, isSet as pt, identifyType as q, TypeAnnotation as r, isInteger as rt, CompilerContext as s, isNumeric as st, Inject as t, isFunction as tt, ClassType as u, isPlainObject as ut, applyDefaults as v, lastKey as vt, collectForMicrotask as w, rangeArray as wt, asyncOperation as x, prependObjectKeys as xt, assertDefined as y, mergePromiseStack as yt, getClassTypeFromInstance as z };
+//# sourceMappingURL=types-Bb6lL3KL.d.cts.map

package/dist/types.d.cts

@@ -1,4 +1,5 @@
-import { S as SerializedTypes } from "./reflection-C4IlLDrv.cjs";
+import { S as SerializedTypes } from "./reflection-DGOuMF8F.cjs";
+import { Yt as ReflectionClass } from "./type-8AL5U7vn.cjs";
 
 //#region src/types.d.ts
 type Reflection<T extends Record<string, any> = Record<string, any>> = ReflectionClass<T> & {
@@ -7,9 +8,6 @@ type Reflection<T extends Record<string, any> = Record<string, any>> = Reflectio
 };
 type ReflectionRecord<T extends Record<string, any> = Record<string, any>> = Record<string, Reflection<T>>;
 interface ContextReflectionRecord<T extends Record<string, any> = Record<string, any>> extends Record<string, Reflection<T> | ContextReflectionRecord<T>> {}
-declare type __ΩReflection = any[];
-declare type __ΩReflectionRecord = any[];
-declare type __ΩContextReflectionRecord = any[];
 //#endregion
-export { ContextReflectionRecord, Reflection, ReflectionRecord, __ΩContextReflectionRecord, __ΩReflection, __ΩReflectionRecord };
+export { ContextReflectionRecord, Reflection, ReflectionRecord };
 //# sourceMappingURL=types.d.cts.map

package/dist/types.d.mts

@@ -1,4 +1,5 @@
-import { S as SerializedTypes } from "./reflection-BB3pXP5l.mjs";
+import { S as SerializedTypes } from "./reflection-Bhe75GyI.mjs";
+import { Yt as ReflectionClass } from "./type-BDuj5wg2.mjs";
 
 //#region src/types.d.ts
 type Reflection<T extends Record<string, any> = Record<string, any>> = ReflectionClass<T> & {
@@ -7,9 +8,6 @@ type Reflection<T extends Record<string, any> = Record<string, any>> = Reflectio
 };
 type ReflectionRecord<T extends Record<string, any> = Record<string, any>> = Record<string, Reflection<T>>;
 interface ContextReflectionRecord<T extends Record<string, any> = Record<string, any>> extends Record<string, Reflection<T> | ContextReflectionRecord<T>> {}
-declare type __ΩReflection = any[];
-declare type __ΩReflectionRecord = any[];
-declare type __ΩContextReflectionRecord = any[];
 //#endregion
-export { ContextReflectionRecord, Reflection, ReflectionRecord, __ΩContextReflectionRecord, __ΩReflection, __ΩReflectionRecord };
+export { ContextReflectionRecord, Reflection, ReflectionRecord };
 //# sourceMappingURL=types.d.mts.map