@wener/utils 1.1.51 → 1.1.54

package/src/langs/deepEqual.ts

@@ -2,9 +2,9 @@ const has = Object.prototype.hasOwnProperty;
 const hasElementType = typeof Element !== 'undefined';
 
 function find(iter: any, tar: any, key?: any) {
-  for (key of iter.keys()) {
-    if (deepEqual(key, tar)) return key;
-  }
+	for (key of iter.keys()) {
+		if (deepEqual(key, tar)) return key;
+	}
 }
 
 /**
@@ -13,94 +13,94 @@ function find(iter: any, tar: any, key?: any) {
  * @see {@link https://github.com/FormidableLabs/react-fast-compare/blob/master/index.js react-fast-compare/index.js}
  */
 export function deepEqual(foo: any, bar: any) {
-  let ctor, len, tmp;
-  if (foo === bar) return true;
+	let ctor, len, tmp;
+	if (foo === bar) return true;
 
-  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
-    if (ctor === Date) return foo.getTime() === bar.getTime();
-    if (ctor === RegExp) return foo.toString() === bar.toString();
+	if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+		if (ctor === Date) return foo.getTime() === bar.getTime();
+		if (ctor === RegExp) return foo.toString() === bar.toString();
 
-    if (ctor === Array) {
-      if ((len = foo.length) === bar.length) {
-        while (len-- && deepEqual(foo[len], bar[len]));
-      }
-      return len === -1;
-    }
+		if (ctor === Array) {
+			if ((len = foo.length) === bar.length) {
+				while (len-- && deepEqual(foo[len], bar[len]));
+			}
+			return len === -1;
+		}
 
-    if (ctor === Set) {
-      if (foo.size !== bar.size) {
-        return false;
-      }
-      for (len of foo) {
-        tmp = len;
-        if (tmp && typeof tmp === 'object') {
-          tmp = find(bar, tmp);
-          if (!tmp) return false;
-        }
-        if (!bar.has(tmp)) return false;
-      }
-      return true;
-    }
+		if (ctor === Set) {
+			if (foo.size !== bar.size) {
+				return false;
+			}
+			for (len of foo) {
+				tmp = len;
+				if (tmp && typeof tmp === 'object') {
+					tmp = find(bar, tmp);
+					if (!tmp) return false;
+				}
+				if (!bar.has(tmp)) return false;
+			}
+			return true;
+		}
 
-    if (ctor === Map) {
-      if (foo.size !== bar.size) {
-        return false;
-      }
-      for (len of foo) {
-        tmp = len[0];
-        if (tmp && typeof tmp === 'object') {
-          tmp = find(bar, tmp);
-          if (!tmp) return false;
-        }
-        if (!deepEqual(len[1], bar.get(tmp))) {
-          return false;
-        }
-      }
-      return true;
-    }
+		if (ctor === Map) {
+			if (foo.size !== bar.size) {
+				return false;
+			}
+			for (len of foo) {
+				tmp = len[0];
+				if (tmp && typeof tmp === 'object') {
+					tmp = find(bar, tmp);
+					if (!tmp) return false;
+				}
+				if (!deepEqual(len[1], bar.get(tmp))) {
+					return false;
+				}
+			}
+			return true;
+		}
 
-    if (ctor === ArrayBuffer) {
-      foo = new Uint8Array(foo);
-      bar = new Uint8Array(bar);
-    } else if (ctor === DataView) {
-      if ((len = foo.byteLength) === bar.byteLength) {
-        while (len-- && foo.getInt8(len) === bar.getInt8(len));
-      }
-      return len === -1;
-    }
+		if (ctor === ArrayBuffer) {
+			foo = new Uint8Array(foo);
+			bar = new Uint8Array(bar);
+		} else if (ctor === DataView) {
+			if ((len = foo.byteLength) === bar.byteLength) {
+				while (len-- && foo.getInt8(len) === bar.getInt8(len));
+			}
+			return len === -1;
+		}
 
-    if (ArrayBuffer.isView(foo)) {
-      if ((len = foo.byteLength) === bar.byteLength) {
-        while (len-- && (foo as any)[len] === bar[len]);
-      }
-      return len === -1;
-    }
+		if (ArrayBuffer.isView(foo)) {
+			if ((len = foo.byteLength) === bar.byteLength) {
+				while (len-- && (foo as any)[len] === bar[len]);
+			}
+			return len === -1;
+		}
 
-    // react & dom
-    if (hasElementType && foo instanceof Element) return false;
+		// react & dom
+		if (hasElementType && foo instanceof Element) return false;
 
-    if (!ctor || typeof foo === 'object') {
-      len = 0;
-      for (ctor in foo) {
-        if ((ctor === '_owner' || ctor === '__v' || ctor === '__o') && foo.$$typeof) {
-          // React-specific: avoid traversing React elements' _owner
-          // Preact-specific: avoid traversing Preact elements' __v and __o
-          //    __v = $_original / $_vnode
-          //    __o = $_owner
-          // These properties contain circular references and are not needed when
-          // comparing the actual elements (and not their owners)
-          // .$$typeof and ._store on just reasonable markers of elements
+		if (!ctor || typeof foo === 'object') {
+			len = 0;
+			for (ctor in foo) {
+				if ((ctor === '_owner' || ctor === '__v' || ctor === '__o') && foo.$$typeof) {
+					// React-specific: avoid traversing React elements' _owner
+					// Preact-specific: avoid traversing Preact elements' __v and __o
+					//    __v = $_original / $_vnode
+					//    __o = $_owner
+					// These properties contain circular references and are not needed when
+					// comparing the actual elements (and not their owners)
+					// .$$typeof and ._store on just reasonable markers of elements
 
-          continue;
-        }
+					continue;
+				}
 
-        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
-        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor])) return false;
-      }
-      return Object.keys(bar).length === len;
-    }
-  }
+				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+				if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor])) return false;
+			}
+			return Object.keys(bar).length === len;
+		}
+	}
 
-  // eslint-disable-next-line no-self-compare
-  return foo !== foo && bar !== bar;
+	// eslint-disable-next-line no-self-compare
+	return foo !== foo && bar !== bar;
 }

package/src/langs/deepFreeze.ts

@@ -5,15 +5,15 @@
  * @returns {T} - The frozen object.
  */
 export function deepFreeze<T>(obj: T): T {
-  if (obj === null || typeof obj !== 'object') {
-    return obj;
-  }
-  const props = Object.getOwnPropertyNames(obj);
-  for (const prop of props) {
-    const value = (obj as any)[prop];
-    if (value && typeof value === 'object') {
-      deepFreeze(value);
-    }
-  }
-  return Object.freeze(obj);
+	if (obj === null || typeof obj !== 'object') {
+		return obj;
+	}
+	const props = Object.getOwnPropertyNames(obj);
+	for (const prop of props) {
+		const value = (obj as any)[prop];
+		if (value && typeof value === 'object') {
+			deepFreeze(value);
+		}
+	}
+	return Object.freeze(obj);
 }

package/src/langs/getGlobalStates.ts

@@ -6,26 +6,26 @@ let _holder: any;
 export function setGlobalStates(states: Record<string, any>): Record<string, any>;
 export function setGlobalStates<V = any>(key: string, value: V): V | undefined;
 export function setGlobalStates(a: any, b?: any) {
-  if (typeof a === 'string') {
-    let s = getGlobalStates();
-    const last = s[a];
-    s[a] = b;
-    return last;
-  } else if (typeof a === 'object') {
-    _holder = a;
-  }
+	if (typeof a === 'string') {
+		let s = getGlobalStates();
+		const last = s[a];
+		s[a] = b;
+		return last;
+	} else if (typeof a === 'object') {
+		_holder = a;
+	}
 }
 
 export function getGlobalStates(): Record<string, any>;
 export function getGlobalStates<T>(key: string, create: () => T): T;
 export function getGlobalStates<T>(key: string): T | undefined;
 export function getGlobalStates(key?: string, create?: () => any): any {
-  _holder ||= (getGlobalThis() as any).__GLOBAL_STATES__ ||= {};
-  if (key) {
-    if (!create) {
-      return _holder[key];
-    }
-    return computeIfAbsent(_holder, key, create);
-  }
-  return _holder;
+	_holder ||= (getGlobalThis() as any).__GLOBAL_STATES__ ||= {};
+	if (key) {
+		if (!create) {
+			return _holder[key];
+		}
+		return computeIfAbsent(_holder, key, create);
+	}
+	return _holder;
 }

package/src/langs/getObjectId.ts

@@ -1,20 +1,17 @@
 import { getGlobalStates } from './getGlobalStates';
 
 export function getObjectId(k: any): number {
-  const state = getGlobalStates('ObjectId', () => {
-    return {
-      id: 1,
-      map: new WeakMap(),
-    };
-  });
+	const state = getGlobalStates('ObjectId', () => {
+		return { id: 1, map: new WeakMap() };
+	});
 
-  const { map } = state;
+	const { map } = state;
 
-  if (map.has(k)) {
-    return map.get(k);
-  }
+	if (map.has(k)) {
+		return map.get(k);
+	}
 
-  const id = state.id++;
-  map.set(k, id);
-  return id;
+	const id = state.id++;
+	map.set(k, id);
+	return id;
 }

package/src/langs/ifPresent.ts

@@ -1,3 +1,3 @@
-export function ifPresent<T, R>(value: T, fn: (v: T) => R): R | undefined {
-  return value ? fn(value) : undefined;
+export function ifPresent<T, R>(value: T, fn: (v: NonNullable<T>) => R): R | undefined {
+	return value ? fn(value) : undefined;
 }

package/src/langs/isClass.ts

@@ -1,3 +1,3 @@
 export function isClass(func: any) {
-  return typeof func === 'function' && /^class\s/.test(Function.prototype.toString.call(func));
+	return typeof func === 'function' && /^class\s/.test(Function.prototype.toString.call(func));
 }

package/src/langs/isDefined.ts

@@ -1,3 +1,3 @@
 export function isDefined<T = any>(v: T): v is NonNullable<T> {
-  return v !== null && v !== undefined;
+	return v !== null && v !== undefined;
 }

package/src/langs/isEmptyObject.ts

@@ -1,5 +1,5 @@
 import { isPlainObject } from './isPlainObject';
 
 export function isEmptyObject(o: any) {
-  return isPlainObject(o) && Object.keys(o).length === 0;
+	return isPlainObject(o) && Object.keys(o).length === 0;
 }

package/src/langs/isFunction.ts

@@ -1,3 +1,3 @@
 export function isFunction(value: any): value is Function {
-  return typeof value === 'function';
+	return typeof value === 'function';
 }

package/src/langs/isNil.ts

@@ -0,0 +1,3 @@
+export function isNil(value: any): value is null | undefined {
+	return value === null || value === undefined;
+}

package/src/langs/isPlainObject.ts

@@ -3,8 +3,8 @@ import { classOf } from './classOf';
 // see: https://github.com/mesqueeb/is-what/blob/88d6e4ca92fb2baab6003c54e02eedf4e729e5ab/src/index.ts
 
 export function isPlainObject(value: any): value is Record<string, any> {
-  if (classOf(value) !== 'Object') {
-    return false;
-  }
-  return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
+	if (classOf(value) !== 'Object') {
+		return false;
+	}
+	return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
 }

package/src/langs/langs.test.ts

@@ -2,22 +2,22 @@ import { expect, test } from 'vitest';
 import { classOf } from './classOf';
 
 test('classOf', () => {
-  for (const [k, v] of [
-    [0, 'Number'],
-    ['', 'String'],
-    [true, 'Boolean'],
-    [null, 'Null'],
-    [undefined, 'Undefined'],
-    [{}, 'Object'],
-    [[], 'Array'],
-    [new ArrayBuffer(0), 'ArrayBuffer'],
-    [new Map(), 'Map'],
-    [new Set(), 'Set'],
-    [new Date(), 'Date'],
-    [new RegExp(''), 'RegExp'],
-    [new DataView(new ArrayBuffer(0)), 'DataView'],
-    [new Int8Array(0), 'Int8Array'],
-  ]) {
-    expect(classOf(k)).toBe(v);
-  }
+	for (const [k, v] of [
+		[0, 'Number'],
+		['', 'String'],
+		[true, 'Boolean'],
+		[null, 'Null'],
+		[undefined, 'Undefined'],
+		[{}, 'Object'],
+		[[], 'Array'],
+		[new ArrayBuffer(0), 'ArrayBuffer'],
+		[new Map(), 'Map'],
+		[new Set(), 'Set'],
+		[new Date(), 'Date'],
+		[new RegExp(''), 'RegExp'],
+		[new DataView(new ArrayBuffer(0)), 'DataView'],
+		[new Int8Array(0), 'Int8Array'],
+	]) {
+		expect(classOf(k)).toBe(v);
+	}
 });

package/src/langs/memoize.ts

@@ -2,31 +2,31 @@
 type func = (...args: any) => any;
 
 export function memoize<T extends func>(
-  callback: T,
-  {
-    resolver = (...args: Parameters<T>) => JSON.stringify(args),
-  }: { resolver?: (...args: Parameters<T>) => string } = {},
+	callback: T,
+	{
+		resolver = (...args: Parameters<T>) => JSON.stringify(args),
+	}: { resolver?: (...args: Parameters<T>) => string } = {},
 ): T {
-  if (typeof callback !== 'function') {
-    throw new Error('`callback` should be a function');
-  }
+	if (typeof callback !== 'function') {
+		throw new Error('`callback` should be a function');
+	}
 
-  if (resolver !== undefined && typeof resolver !== 'function') {
-    throw new Error('`resolver` should be a function');
-  }
+	if (resolver !== undefined && typeof resolver !== 'function') {
+		throw new Error('`resolver` should be a function');
+	}
 
-  const cache: Record<string, any> = {};
+	const cache: Record<string, any> = {};
 
-  const memoized = function (this: any) {
-    const args = Array.prototype.slice.call(arguments); // to simplify JSON.stringify
-    const key = resolver.apply(this, args as Parameters<T>);
+	const memoized = function (this: any) {
+		const args = Array.prototype.slice.call(arguments); // to simplify JSON.stringify
+		const key = resolver.apply(this, args as Parameters<T>);
 
-    if (!(key in cache)) {
-      cache[key] = callback.apply(this, args);
-    }
+		if (!(key in cache)) {
+			cache[key] = callback.apply(this, args);
+		}
 
-    return cache[key];
-  };
-  memoized.cache = cache;
-  return memoized as func as T;
+		return cache[key];
+	};
+	memoized.cache = cache;
+	return memoized as func as T;
 }

package/src/langs/mixin.test.ts

@@ -4,40 +4,36 @@ import { mixin } from './mixin';
 export type Constructor<T = {}> = new (...args: any[]) => T;
 
 test('mixin', () => {
-  // @ts-ignore
-  class User extends mixin(BaseResource, createBarFields()) {}
-
-  let usr = new User();
-  // type not working
-  // @ts-ignore
-  expect(usr.foo, 'foo');
-  expect(usr).toEqual({
-    foo: 'foo',
-    bar: 'bar',
-    id: '',
-  });
+	// @ts-ignore
+	class User extends mixin(BaseResource, createBarFields()) {}
+
+	let usr = new User();
+	// type not working
+	// @ts-ignore
+	expect(usr.foo, 'foo');
+	expect(usr).toEqual({ foo: 'foo', bar: 'bar', id: '' });
 });
 
 class BaseResource {
-  id?: string = '';
+	id?: string = '';
 }
 
 function createBarFields() {
-  return <TBase extends Constructor>(Base: TBase) => {
-    // nested type not working
-    // @ts-ignore
-    class HasBarMixin extends mixin(Base, withFooFields) {
-      bar?: string = 'bar';
-    }
-
-    return HasBarMixin;
-  };
+	return <TBase extends Constructor>(Base: TBase) => {
+		// nested type not working
+		// @ts-ignore
+		class HasBarMixin extends mixin(Base, withFooFields) {
+			bar?: string = 'bar';
+		}
+
+		return HasBarMixin;
+	};
 }
 
 function withFooFields<TBase extends Constructor>(Base: TBase) {
-  class HasFieldFooMixin extends Base {
-    foo?: string = 'foo';
-  }
+	class HasFieldFooMixin extends Base {
+		foo?: string = 'foo';
+	}
 
-  return HasFieldFooMixin;
+	return HasFieldFooMixin;
 }

package/src/langs/mixin.ts

@@ -34,7 +34,7 @@ export type MixinConstructor<T = {}> = new (...args: any[]) => T;
  * @typeParam R The type of the returned class.
  */
 export type MixinFunction<T extends MixinConstructor = MixinConstructor, R extends T = T & MixinConstructor> = (
-  Base: T,
+	Base: T,
 ) => R;
 
 /**
@@ -44,10 +44,7 @@ export type MixinFunction<T extends MixinConstructor = MixinConstructor, R exten
  * @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]
+	T | { [K in keyof M]: M[K] extends MixinFunction<any, infer U> ? U : never }[number]
 >;
 
 /**
@@ -56,7 +53,7 @@ export type MixinReturnValue<T extends MixinConstructor, M extends MixinFunction
  * @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;
+	F extends MixinFunction<MixinConstructor<any>, infer R> ? InstanceType<R> : never;
 
 /**
  * Applies the given mixins to the a common base class.
@@ -73,10 +70,10 @@ export type MixinInstance<F extends MixinFunction<any>> =
  * ```
  */
 export function mixin<T extends MixinConstructor, M extends MixinFunction<T, any>[]>(
-  Base: T,
-  ...mixins: M
+	Base: T,
+	...mixins: M
 ): MixinReturnValue<T, M> {
-  return mixins.reduce((mix, applyMixin) => applyMixin(mix), Base) as MixinReturnValue<T, M>;
+	return mixins.reduce((mix, applyMixin) => applyMixin(mix), Base) as MixinReturnValue<T, M>;
 }
 
 // https://github.com/1nVitr0/lib-ts-mixin-extended

package/src/langs/parseBoolean.ts

@@ -1,30 +1,34 @@
 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 {
-  if (typeof s === 'boolean') {
-    return s;
-  }
-  if (typeof s === 'string') {
-    switch (s.toLowerCase()) {
-      case 'f':
-      case 'false':
-      case '0':
-        return false;
-      case '1':
-      case 't':
-      case 'true':
-        return true;
-    }
-  } else if (typeof s === 'number') {
-    switch (s) {
-      case 0:
-        return false;
-      case 1:
-        return true;
-    }
-  }
-  if (strict) {
-    return undefined;
-  }
-  return Boolean(s);
+	if (typeof s === 'boolean') {
+		return s;
+	}
+	if (typeof s === 'string') {
+		switch (s.toLowerCase()) {
+			case 'yes':
+			case 'y':
+			case 'true':
+			case 't':
+			case '1':
+				return true;
+			case 'no':
+			case 'n':
+			case 'false':
+			case 'f':
+			case '0':
+				return false;
+		}
+	} else if (typeof s === 'number') {
+		switch (s) {
+			case 0:
+				return false;
+			case 1:
+				return true;
+		}
+	}
+	if (strict) {
+		return undefined;
+	}
+	return Boolean(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/langs/shallowClone.ts

@@ -1,13 +1,13 @@
 export function shallowClone<T>(obj: T): T {
-  if (!obj) {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.slice() as T;
-  }
-  if (typeof obj === 'object') {
-    return Object.assign({}, obj);
-  }
-  // skip Map, Set, WeakMap, WeakSet, Date, RegExp, etc.
-  return obj;
+	if (!obj) {
+		return obj;
+	}
+	if (Array.isArray(obj)) {
+		return obj.slice() as T;
+	}
+	if (typeof obj === 'object') {
+		return Object.assign({}, obj);
+	}
+	// skip Map, Set, WeakMap, WeakSet, Date, RegExp, etc.
+	return obj;
 }