@wener/utils 1.1.53 → 1.1.56

package/src/langs/mixin.test.ts

@@ -1,9 +1,43 @@
 import { expect, test } from 'vitest';
 import { mixin } from './mixin';
 
-export type Constructor<T = {}> = new (...args: any[]) => T;
+// import type { Constructor } from '#/types';
+type Constructor<T = {}> = new (...args: any[]) => T;
+function Ent<T extends Function>(): (target: T) => void {
+	return () => {};
+}
 
 test('mixin', () => {
+	// @Ent()
+	class User extends mixin(BaseResource, withFooFields) {
+		a?: string;
+	}
+	// @Ent()
+	class User2 extends mixin(BaseEnt, withFooFields) {
+		x: string = 'x';
+	}
+
+	// type works
+	const usr = new User();
+	expect(usr.foo, 'foo');
+
+	const u2 = new User2();
+	console.log(u2);
+});
+
+//  <T extends EntityClass<unknown>>(options?: EntityOptions<T>): (target: T) => void;
+
+// @Ent()
+class BaseResource {
+	id?: string = '';
+}
+
+// @Ent()
+class BaseEnt extends BaseResource {
+	base: string = 'base';
+}
+
+test('mixin deep not working', () => {
 	// @ts-ignore
 	class User extends mixin(BaseResource, createBarFields()) {}
 
@@ -14,10 +48,6 @@ test('mixin', () => {
 	expect(usr).toEqual({ foo: 'foo', bar: 'bar', id: '' });
 });
 
-class BaseResource {
-	id?: string = '';
-}
-
 function createBarFields() {
 	return <TBase extends Constructor>(Base: TBase) => {
 		// nested type not working

package/src/langs/mixin.ts

@@ -1,79 +1,60 @@
-/**
- * Helper type to convert a union to an intersection.
- *
- * @internal
- */
-type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+import type { Constructor } from '../types';
 
 /**
- * Constructor function, that creates a new instance of the given type.
- *
- * @typeParam T The type of the instance to create.
- * @example ```ts
- * function Walkable<TBase extends MixinConstructor<Positionable>>(Base: TBase) {
- * ··return class Walkable extends Base {
- * ····public forward() { this.x++; }
- * ····public backward() { this.x--; }
- * ··};
- * }
- * ```
- * @example ```ts
- * function Loggable(Base: MixinConstructor) {
- * ··return class Loggable extends Base {
- * ····public log(message: string) { throw new Error(404); }
- * ··};
- * }
- * ```
+ * Mixin function type - takes a base class and returns an extended class
  */
-export type MixinConstructor<T = {}> = new (...args: any[]) => T;
+export type MixinFn<TBase extends Constructor = Constructor, TResult extends TBase = TBase> = (Base: TBase) => TResult;
 
-/**
- * Function that applies a mixin to a given base class.
- *
- * @typeParam T The type of the base class.
- * @typeParam R The type of the returned class.
- */
-export type MixinFunction<T extends MixinConstructor = MixinConstructor, R extends T = T & MixinConstructor> = (
+export function mixin<T extends Constructor>(Base: T): T;
+export function mixin<T extends Constructor, M1 extends MixinFn<T>>(Base: T, m1: M1): ReturnType<M1>;
+export function mixin<T extends Constructor, M1 extends MixinFn<T>, M2 extends MixinFn<ReturnType<M1>>>(
 	Base: T,
-) => R;
-
-/**
- * The return type of the mixin function.
- *
- * @typeParam T The type of the base class.
- * @typeParam M The type of the mixin functions.
- */
-export type MixinReturnValue<T extends MixinConstructor, M extends MixinFunction<T, any>[]> = UnionToIntersection<
-	T | { [K in keyof M]: M[K] extends MixinFunction<any, infer U> ? U : never }[number]
->;
-
-/**
- * The instance created by a mixin function.
- *
- * @typeParam F The type of the mixin function.
- */
-export type MixinInstance<F extends MixinFunction<any>> =
-	F extends MixinFunction<MixinConstructor<any>, infer R> ? InstanceType<R> : never;
+	m1: M1,
+	m2: M2,
+): ReturnType<M2>;
+export function mixin<
+	T extends Constructor,
+	M1 extends MixinFn<T>,
+	M2 extends MixinFn<ReturnType<M1>>,
+	M3 extends MixinFn<ReturnType<M2>>,
+>(Base: T, m1: M1, m2: M2, m3: M3): ReturnType<M3>;
+export function mixin<
+	T extends Constructor,
+	M1 extends MixinFn<T>,
+	M2 extends MixinFn<ReturnType<M1>>,
+	M3 extends MixinFn<ReturnType<M2>>,
+	M4 extends MixinFn<ReturnType<M3>>,
+>(Base: T, m1: M1, m2: M2, m3: M3, m4: M4): ReturnType<M4>;
+export function mixin<
+	T extends Constructor,
+	M1 extends MixinFn<T>,
+	M2 extends MixinFn<ReturnType<M1>>,
+	M3 extends MixinFn<ReturnType<M2>>,
+	M4 extends MixinFn<ReturnType<M3>>,
+	M5 extends MixinFn<ReturnType<M4>>,
+>(Base: T, m1: M1, m2: M2, m3: M3, m4: M4, m5: M5): ReturnType<M5>;
+export function mixin<
+	T extends Constructor,
+	M1 extends MixinFn<T>,
+	M2 extends MixinFn<ReturnType<M1>>,
+	M3 extends MixinFn<ReturnType<M2>>,
+	M4 extends MixinFn<ReturnType<M3>>,
+	M5 extends MixinFn<ReturnType<M4>>,
+	M6 extends MixinFn<ReturnType<M5>>,
+>(Base: T, m1: M1, m2: M2, m3: M3, m4: M4, m5: M5, m6: M6): ReturnType<M6>;
 
 /**
- * Applies the given mixins to the a common base class.
+ * Applies the given mixins to a common base class.
  *
  * @param Base The base class to apply the mixins to.
- * @param mixins The mixins to apply. All mixins must extend a common base class or an empty class.
+ * @param mixins The mixins to apply sequentially.
  * @returns A class constructor with all mixins applied.
  *
- * @typeParam T The type of the base class.
- * @typeParam M The type of the mixin functions.
- *
- * @example ```ts
- * class Dog extends mixin(Animal, FourLegged, Carnivore, PackHunting, Barking, Domesticated) {}
+ * @example
+ * ```ts
+ * class Dog extends mixin(Animal, FourLegged, Carnivore) {}
  * ```
  */
-export function mixin<T extends MixinConstructor, M extends MixinFunction<T, any>[]>(
-	Base: T,
-	...mixins: M
-): MixinReturnValue<T, M> {
-	return mixins.reduce((mix, applyMixin) => applyMixin(mix), Base) as MixinReturnValue<T, M>;
+export function mixin<T extends Constructor>(Base: T, ...mixins: MixinFn<any>[]): Constructor {
+	return mixins.reduce((mix, applyMixin) => applyMixin(mix), Base as Constructor);
 }
-
-// https://github.com/1nVitr0/lib-ts-mixin-extended

package/src/langs/mixin2.ts

@@ -0,0 +1,80 @@
+/**
+ * Helper type to convert a union to an intersection.
+ *
+ * @internal
+ */
+type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+
+/**
+ * Constructor function, that creates a new instance of the given type.
+ *
+ * @typeParam T The type of the instance to create.
+ * @example ```ts
+ * function Walkable<TBase extends MixinConstructor<Positionable>>(Base: TBase) {
+ * ··return class Walkable extends Base {
+ * ····public forward() { this.x++; }
+ * ····public backward() { this.x--; }
+ * ··};
+ * }
+ * ```
+ * @example ```ts
+ * function Loggable(Base: MixinConstructor) {
+ * ··return class Loggable extends Base {
+ * ····public log(message: string) { throw new Error(404); }
+ * ··};
+ * }
+ * ```
+ */
+export type MixinConstructor<T = {}> = new (...args: any[]) => T;
+
+/**
+ * Function that applies a mixin to a given base class.
+ *
+ * @typeParam T The type of the base class.
+ * @typeParam R The type of the returned class.
+ */
+export type MixinFunction<T extends MixinConstructor = MixinConstructor, R extends T = T & MixinConstructor> = (
+	Base: T,
+) => R;
+
+/**
+ * The return type of the mixin function.
+ *
+ * @typeParam T The type of the base class.
+ * @typeParam M The type of the mixin functions.
+ */
+export type MixinReturnValue<T extends MixinConstructor, M extends MixinFunction<T, any>[]> = UnionToIntersection<
+	T | { [K in keyof M]: M[K] extends MixinFunction<any, infer U> ? U : never }[number]
+>;
+
+/**
+ * The instance created by a mixin function.
+ *
+ * @typeParam F The type of the mixin function.
+ */
+export type MixinInstance<F extends MixinFunction<any>> =
+	F extends MixinFunction<MixinConstructor<any>, infer R> ? InstanceType<R> : never;
+
+/**
+ * Applies the given mixins to the a common base class.
+ *
+ * @param Base The base class to apply the mixins to.
+ * @param mixins The mixins to apply. All mixins must extend a common base class or an empty class.
+ * @returns A class constructor with all mixins applied.
+ *
+ * @typeParam T The type of the base class.
+ * @typeParam M The type of the mixin functions.
+ *
+ * @example ```ts
+ * class Dog extends mixin(Animal, FourLegged, Carnivore, PackHunting, Barking, Domesticated) {}
+ * ```
+ */
+export function mixin<T extends MixinConstructor, M extends MixinFunction<T, any>[]>(
+	Base: T,
+	...mixins: M
+): MixinReturnValue<T, M> {
+	return mixins.reduce((mix, applyMixin) => applyMixin(mix), Base) as MixinReturnValue<T, M>;
+}
+
+// this is complex, may cause ts unable to resolve prototype typing
+// https://github.com/1nVitr0/lib-ts-mixin-extended

package/src/langs/parseBoolean.ts

@@ -1,6 +1,14 @@
+export interface ParseBooleanOptions {
+	strict?: boolean;
+}
+
+export function parseBoolean(s: string | boolean | number | null | undefined, options: { strict: true }): boolean | undefined;
+export function parseBoolean(s: string | boolean | number | null | undefined | any, options?: ParseBooleanOptions): boolean;
+/** @deprecated Use `parseBoolean(s, { strict: true })` instead */
 export function parseBoolean(s: string | boolean | number | null | undefined, strict: true): boolean | undefined;
 export function parseBoolean(s: string | boolean | number | null | undefined | any): boolean;
-export function parseBoolean(s?: string | boolean | number | null, strict = false): boolean | undefined {
+export function parseBoolean(s?: string | boolean | number | null, options?: boolean | ParseBooleanOptions): boolean | undefined {
+	const strict = typeof options === 'boolean' ? options : options?.strict ?? false;
 	if (typeof s === 'boolean') {
 		return s;
 	}

package/src/langs/parseDate.ts

@@ -0,0 +1,13 @@
+export function parseDate(value: Date | string | undefined | null): Date | undefined {
+	if (!value) {
+		return undefined;
+	}
+	if (value instanceof Date) {
+		return value;
+	}
+	const parsed = new Date(value);
+	if (isNaN(parsed.getTime())) {
+		return undefined;
+	}
+	return parsed;
+}

package/src/objects/set.ts

@@ -13,7 +13,9 @@ export function set<T extends object, V>(obj: T, key: ObjectKey | ObjectPath, va
 	let x, k;
 	while (i < len) {
 		k = path[i++];
+		// Security: Prevent prototype pollution
 		if (k === '__proto__' || k === 'constructor' || k === 'prototype') break;
+
 		// noinspection PointlessArithmeticExpressionJS
 		current = current[k] =
 			i === len
@@ -22,7 +24,14 @@ export function set<T extends object, V>(obj: T, key: ObjectKey | ObjectPath, va
 					: val
 				: typeof (x = current[k]) === typeof path
 					? x
-					: // @ts-expect-error hacky type check
+					: // Determine if we should create an Object or an Array for the next level
+						// If the next key is NOT an integer-like index, or contains a dot, create an Object.
+						// Otherwise, create an Array.
+						//
+						// path[i] * 0 !== 0 checks if it is NOT a number (NaN * 0 is NaN).
+						// !!~('' + path[i]).indexOf('.') checks if it contains a dot.
+						//
+						// @ts-expect-error hacky type check from dset
 						path[i] * 0 !== 0 || !!~('' + path[i]).indexOf('.') // eslint-disable-line
 						? {}
 						: [];

package/src/types.d.ts

@@ -1,6 +1,6 @@
 declare var __DEV__: boolean;
 
-namespace NodeJS {
+declare namespace NodeJS {
 	interface Process {
 		// webpack check
 		readonly browser?: boolean;

package/tsconfig.json

@@ -3,17 +3,13 @@
 		"moduleResolution": "bundler",
 		"target": "ESNext",
 		"module": "ESNext",
-		"lib": [
-			"dom",
-			"dom.iterable",
-			"ESNext"
-		],
+		"lib": ["dom", "dom.iterable", "ESNext"],
 		"strict": true,
 		"sourceMap": true,
 		"skipLibCheck": true,
 		"esModuleInterop": true,
 		"verbatimModuleSyntax": true,
-		"erasableSyntaxOnly": true,
+		"erasableSyntaxOnly": false,
 		"allowSyntheticDefaultImports": true,
 		"noImplicitAny": true,
 		"noImplicitReturns": true,
@@ -25,13 +21,11 @@
 		"isolatedModules": true,
 		"outDir": "lib",
 		"baseUrl": ".",
-		"rootDir": "./src"
+		"rootDir": "./src",
+		"paths": {
+			"#/*": ["./src/*"]
+		}
 	},
-	"exclude": [
-		"node_modules"
-	],
-	"include": [
-		"src/types.d.ts",
-		"src"
-	]
+	"exclude": ["node_modules", "**/*.test.ts", "**/*.spec.ts"],
+	"include": ["src/types.d.ts", "src"]
 }

package/lib/errors/Errors.mod.js

@@ -1,206 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    }
-    else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _instanceof(left, right) {
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    }
-    else {
-        return left instanceof right;
-    }
-}
-function _object_spread(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function (key) {
-            _define_property(target, key, source[key]);
-        });
-    }
-    return target;
-}
-function ownKeys(object, enumerableOnly) {
-    var keys = Object.keys(object);
-    if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
-        if (enumerableOnly) {
-            symbols = symbols.filter(function (sym) {
-                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-            });
-        }
-        keys.push.apply(keys, symbols);
-    }
-    return keys;
-}
-function _object_spread_props(target, source) {
-    source = source != null ? source : {};
-    if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    }
-    else {
-        ownKeys(Object(source)).forEach(function (key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
-    }
-    return target;
-}
-import { DetailError, DetailHolder } from "./DetailError.js";
-/*
-https://github.com/tc39/proposal-error-cause
-https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause
-Stage 3
-Chrome 93, Safari 15, Node 16.9
-
-https://www.npmjs.com/package/pony-cause
-   */ export var BadRequest = create({
-    status: 400
-});
-export var Unauthorized = create({
-    status: 403
-});
-export var Forbidden = create({
-    status: 403
-});
-export var NotFound = create({
-    status: 404
-});
-export var InternalServerError = create({
-    status: 500
-});
-export var NotImplemented = create({
-    status: 501
-});
-export var ServiceUnavailable = create({
-    status: 503
-});
-export var IllegalState = create({
-    status: 500,
-    message: "Illegal State"
-});
-export var UnsupportedOperation = create({
-    status: 500,
-    message: "Unsupported Operation"
-});
-export var IllegalArgument = create({
-    status: 400,
-    message: "Illegal Argument"
-});
-export var InvalidType = create({
-    status: 400,
-    message: "Invalid Type"
-});
-// known errors
-// TypeError  when an operation could not be performed, typically (but not exclusively) when a value is not of the expected type.
-// RangeError  when a number is not within the correct range allowed.
-// AggregateError  when multiple errors need to be reported by an operation, for example by Promise.all().
-//  例如 Promise.any() 会返回一个 AggregateError，其中包含所有 rejected 的 Promise 的错误。
-// EvalError  when an error occurs during the evaluation of JavaScript code.
-// ReferenceError  when a non-existent variable is referenced.
-// SyntaxError  when a syntax error occurs while parsing code in eval().
-// URIError  when encodeURI() or decodeURI() are passed invalid parameters.
-// InternalError  when an internal error in the JavaScript engine is thrown. E.g. "too much recursion".
-// DOMException  when an error occurs in the DOM.
-export var resolvers = [];
-export function create(init) {
-    return new DetailHolder(init);
-}
-export function ok(res, o) {
-    if (res.ok) {
-        return res;
-    }
-    throw create(_object_spread_props(_object_spread({
-        description: res.statusText,
-        status: res.status
-    }, o), {
-        metadata: _object_spread_props(_object_spread({}, o === null || o === void 0 ? void 0 : o.metadata), {
-            response: res
-        })
-    })).asError();
-}
-export function resolve(e) {
-    if (_instanceof(e, DetailHolder)) {
-        return e;
-    }
-    if (_instanceof(e, DetailError)) {
-        return e.detail;
-    }
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        for (var _iterator = resolvers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-            var resolver = _step.value;
-            var r = resolver(e);
-            if (r) {
-                return r;
-            }
-        }
-    }
-    catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    }
-    finally {
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-            }
-        }
-        finally {
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
-    }
-    if (isError(e)) {
-        var message = e.message, code = e.code, status = e.status;
-        // can get status from NestJS HttpException
-        return new DetailHolder({
-            message: message,
-            status: parseInt(status) || 500,
-            code: code,
-            cause: e
-        });
-    }
-    return new DetailHolder({
-        message: e.message,
-        status: 500,
-        cause: e
-    });
-}
-/**
- * Check if the given value is an Error
- * @see https://github.com/tc39/proposal-is-error
- */ export function isError(e) {
-    if ("isError" in Error) {
-        // will handle cross-realm
-        return Error.isError(e);
-    }
-    return _instanceof(e, Error);
-}
-export function isAbort(e) {
-    if (!isError(e)) {
-        return false;
-    }
-    return e.name === "AbortError";
-}
-export function isTimeout(e) {
-    if (!isError(e)) {
-        return false;
-    }
-    return e.name === "TimeoutError" || e.name === "Timeout";
-}