@wener/utils 1.1.50 → 1.1.53

package/src/modules/parseModuleId.test.ts

@@ -2,72 +2,65 @@ import { expect, test } from 'vitest';
 import { parseModuleId } from './parseModuleId';
 
 test('parseModuleId', () => {
-  const tests = {
-    '@wener/reaction': {
-      id: `@wener/reaction@latest`,
-      name: '@wener/reaction',
-      range: 'latest',
-      scoped: true,
-      org: 'wener',
-      pkg: 'reaction',
-      versioned: false,
-    },
-    reaction: {
-      id: `reaction@latest`,
-      name: 'reaction',
-      range: 'latest',
-      pkg: 'reaction',
-      scoped: false,
-      versioned: false,
-    },
-    'reaction@1': {
-      id: `reaction@1`,
-      name: 'reaction',
-      range: '1',
-      pkg: 'reaction',
-      scoped: false,
-      versioned: true,
-    },
-    'reaction@1.1.1': {
-      id: `reaction@1.1.1`,
-      name: 'reaction',
-      version: '1.1.1',
-      range: '1.1.1',
-      pkg: 'reaction',
-      scoped: false,
-      versioned: true,
-    },
-    'reaction@1.1.1-alpha': {
-      id: `reaction@1.1.1-alpha`,
-      name: 'reaction',
-      version: '1.1.1-alpha',
-      range: '1.1.1-alpha',
-      pkg: 'reaction',
-      versioned: true,
-      scoped: false,
-    },
-    'reaction@1.1.1/index.js': {
-      id: `reaction@1.1.1`,
-      name: 'reaction',
-      version: '1.1.1',
-      range: '1.1.1',
-      scoped: false,
-      pkg: 'reaction',
-      versioned: true,
-      path: '/index.js',
-    },
-    'reaction@1.1.1/': {
-      id: `reaction@1.1.1`,
-      name: 'reaction',
-      version: '1.1.1',
-      range: '1.1.1',
-      scoped: false,
-      pkg: 'reaction',
-      path: '/',
-      versioned: true,
-    },
-  };
-  for (const [k, v] of Object.entries(tests)) {
-    expect(parseModuleId(k)).toStrictEqual(v);
-  }
+	const tests = {
+		'@wener/reaction': {
+			id: `@wener/reaction@latest`,
+			name: '@wener/reaction',
+			range: 'latest',
+			scoped: true,
+			org: 'wener',
+			pkg: 'reaction',
+			versioned: false,
+		},
+		reaction: {
+			id: `reaction@latest`,
+			name: 'reaction',
+			range: 'latest',
+			pkg: 'reaction',
+			scoped: false,
+			versioned: false,
+		},
+		'reaction@1': { id: `reaction@1`, name: 'reaction', range: '1', pkg: 'reaction', scoped: false, versioned: true },
+		'reaction@1.1.1': {
+			id: `reaction@1.1.1`,
+			name: 'reaction',
+			version: '1.1.1',
+			range: '1.1.1',
+			pkg: 'reaction',
+			scoped: false,
+			versioned: true,
+		},
+		'reaction@1.1.1-alpha': {
+			id: `reaction@1.1.1-alpha`,
+			name: 'reaction',
+			version: '1.1.1-alpha',
+			range: '1.1.1-alpha',
+			pkg: 'reaction',
+			versioned: true,
+			scoped: false,
+		},
+		'reaction@1.1.1/index.js': {
+			id: `reaction@1.1.1`,
+			name: 'reaction',
+			version: '1.1.1',
+			range: '1.1.1',
+			scoped: false,
+			pkg: 'reaction',
+			versioned: true,
+			path: '/index.js',
+		},
+		'reaction@1.1.1/': {
+			id: `reaction@1.1.1`,
+			name: 'reaction',
+			version: '1.1.1',
+			range: '1.1.1',
+			scoped: false,
+			pkg: 'reaction',
+			path: '/',
+			versioned: true,
+		},
+	};
+	for (const [k, v] of Object.entries(tests)) {
+		expect(parseModuleId(k)).toStrictEqual(v);
+	}
 });

package/src/modules/parseModuleId.ts

@@ -1,23 +1,17 @@
 // https://regex101.com/r/eMcXQ9/1
 const regModuleId =
-  /^(?<n>(?:@(?<org>[a-z0-9-~][a-z0-9-._~]*)\/)?(?<pkg>[a-z0-9-~][a-z0-9-._~]*))(?:@(?<v>[-a-z0-9><=_.^~]+))?(?<p>\/[^\r\n]*)?$/;
+	/^(?<n>(?:@(?<org>[a-z0-9-~][a-z0-9-._~]*)\/)?(?<pkg>[a-z0-9-~][a-z0-9-._~]*))(?:@(?<v>[-a-z0-9><=_.^~]+))?(?<p>\/[^\r\n]*)?$/;
 
 export type ParsedModuleId = {
-  id: string; // name@version
-  name: string; // @org/pkg, pkg
-  version?: string; // 1.1.1
-  range: string; // version, tag, range
-  pkg: string;
-  path?: string;
-  org?: string;
-  versioned: boolean; // is module id contain a version specifier
-} & (
-  | { scoped: false }
-  | {
-      scoped: true;
-      org: string;
-    }
-);
+	id: string; // name@version
+	name: string; // @org/pkg, pkg
+	version?: string; // 1.1.1
+	range: string; // version, tag, range
+	pkg: string;
+	path?: string;
+	org?: string;
+	versioned: boolean; // is module id contain a version specifier
+} & ({ scoped: false } | { scoped: true; org: string });
 
 /**
  * Parse NPM module id
@@ -27,31 +21,23 @@ export type ParsedModuleId = {
  * // { id: '@wener/reaction@latest', name: '@wener/reaction', version: 'latest', range: 'latest', pkg: 'reaction', path: '/index.js', scoped: true, org: 'wener' }
  */
 export function parseModuleId(s: string): ParsedModuleId | undefined {
-  const groups = s.match(regModuleId)?.groups;
-  if (!groups) {
-    return undefined;
-  }
-  const { n: name, v: version, p: path, org, pkg } = groups;
-  const scoped = Boolean(org);
-  const v = /^\d+\.\d+\.\d+/.test(version) ? version : undefined;
-  const range = version || 'latest';
-  const o: ParsedModuleId = {
-    id: `${name}@${range}`,
-    name,
-    range,
-    scoped,
-    pkg,
-    org,
-    versioned: Boolean(version),
-  };
-  if (v) {
-    o.version = v;
-  }
-  if (path) {
-    o.path = path;
-  }
-  if (!o.scoped) {
-    delete o.org;
-  }
-  return o;
+	const groups = s.match(regModuleId)?.groups;
+	if (!groups) {
+		return undefined;
+	}
+	const { n: name, v: version, p: path, org, pkg } = groups;
+	const scoped = Boolean(org);
+	const v = /^\d+\.\d+\.\d+/.test(version) ? version : undefined;
+	const range = version || 'latest';
+	const o: ParsedModuleId = { id: `${name}@${range}`, name, range, scoped, pkg, org, versioned: Boolean(version) };
+	if (v) {
+		o.version = v;
+	}
+	if (path) {
+		o.path = path;
+	}
+	if (!o.scoped) {
+		delete o.org;
+	}
+	return o;
 }

package/src/objects/computeIfAbsent.ts

@@ -2,15 +2,15 @@ export function computeIfAbsent<K extends WeakKey, V>(map: WeakMap<K, V>, key: K
 export function computeIfAbsent<K, V>(map: Map<K, V>, key: K, fn: () => V): V;
 export function computeIfAbsent<K extends string | symbol | number, V>(map: Record<K, V>, key: K, fn: () => V): V;
 export function computeIfAbsent(map: any, key: any, fn: () => any): any {
-  if (map instanceof Map || map instanceof WeakMap) {
-    if (!map.has(key)) {
-      map.set(key, fn());
-    }
-    return map.get(key)!;
-  }
+	if (map instanceof Map || map instanceof WeakMap) {
+		if (!map.has(key)) {
+			map.set(key, fn());
+		}
+		return map.get(key)!;
+	}
 
-  if (!map[key]) {
-    map[key] = fn();
-  }
-  return map[key];
+	if (!map[key]) {
+		map[key] = fn();
+	}
+	return map[key];
 }

package/src/objects/get.test-d.ts

@@ -2,58 +2,40 @@ import { expectTypeOf, test } from 'vitest';
 import { get } from './get';
 
 interface TestClass {
-  normal: string;
-  nested: {
-    a: number;
-    b: {
-      c: boolean;
-    };
-  };
-  arr: number[];
-  nestedArr: {
-    sum: number;
-    other: null;
-  }[];
-  deep: {
-    arr: string[];
-  };
-  deeplvl1: {
-    deeplvl2: {
-      deeplvl3: {
-        deeplvl4: {
-          value: RegExp;
-        };
-      }[];
-    };
-  }[];
+	normal: string;
+	nested: { a: number; b: { c: boolean } };
+	arr: number[];
+	nestedArr: { sum: number; other: null }[];
+	deep: { arr: string[] };
+	deeplvl1: { deeplvl2: { deeplvl3: { deeplvl4: { value: RegExp } }[] } }[];
 }
 
 test('get typing', () => {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  const obj = {} as TestClass;
-  expectTypeOf(get(obj, 'nested.a', null)).toMatchTypeOf<number>();
-  expectTypeOf(get(obj, 'normal', null)).toMatchTypeOf<string>();
-  expectTypeOf(get(obj, 'nested.a')).toMatchTypeOf<number>();
-  expectTypeOf(get(obj, 'nested.b.c')).toMatchTypeOf<boolean>();
-  expectTypeOf(get(obj, 'arr')).toMatchTypeOf<number[]>();
-  expectTypeOf(get(obj, 'arr[13]')).toMatchTypeOf<number>();
-  // @ts-ignore
-  expectTypeOf(get(obj, 'arr.13')).toMatchTypeOf<number>();
-  expectTypeOf(get(obj, 'nestedArr[3].other')).toMatchTypeOf<null>();
-  // @ts-ignore
-  expectTypeOf(get(obj, 'deep.deep')).toMatchTypeOf<string[]>();
-  expectTypeOf(get(obj, 'deep.arr[333]')).toMatchTypeOf<string>();
-  expectTypeOf(get(obj, 'deep.arr[333].length')).toMatchTypeOf<number>();
-  // @ts-ignore
-  expectTypeOf(get(obj, 'nested["b"]["c"]')).toMatchTypeOf<boolean>();
-  // @ts-ignore
-  expectTypeOf(get(obj, '')).toMatchTypeOf<never>();
-  expectTypeOf(get(obj, '', 3)).toMatchTypeOf<number>();
-  // @ts-ignore
-  expectTypeOf(get(obj, 'nested.asdfasdf')).toMatchTypeOf<never>();
-  expectTypeOf(get(obj, 'deeplvl1[1].deeplvl2.deeplvl3[88].deeplvl4.value')).toMatchTypeOf<RegExp>();
-  // @ts-ignore
-  expectTypeOf(get(obj, 'deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value')).toMatchTypeOf<never>();
-  expectTypeOf(get(obj, 'deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value', obj)).toMatchTypeOf<TestClass>();
-  expectTypeOf(get(obj, 'nested["dd"]', '')).toMatchTypeOf<string>();
+	// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+	const obj = {} as TestClass;
+	expectTypeOf(get(obj, 'nested.a', null)).toMatchTypeOf<number>();
+	expectTypeOf(get(obj, 'normal', null)).toMatchTypeOf<string>();
+	expectTypeOf(get(obj, 'nested.a')).toMatchTypeOf<number>();
+	expectTypeOf(get(obj, 'nested.b.c')).toMatchTypeOf<boolean>();
+	expectTypeOf(get(obj, 'arr')).toMatchTypeOf<number[]>();
+	expectTypeOf(get(obj, 'arr[13]')).toMatchTypeOf<number>();
+	// @ts-ignore
+	expectTypeOf(get(obj, 'arr.13')).toMatchTypeOf<number>();
+	expectTypeOf(get(obj, 'nestedArr[3].other')).toMatchTypeOf<null>();
+	// @ts-ignore
+	expectTypeOf(get(obj, 'deep.deep')).toMatchTypeOf<string[]>();
+	expectTypeOf(get(obj, 'deep.arr[333]')).toMatchTypeOf<string>();
+	expectTypeOf(get(obj, 'deep.arr[333].length')).toMatchTypeOf<number>();
+	// @ts-ignore
+	expectTypeOf(get(obj, 'nested["b"]["c"]')).toMatchTypeOf<boolean>();
+	// @ts-ignore
+	expectTypeOf(get(obj, '')).toMatchTypeOf<never>();
+	expectTypeOf(get(obj, '', 3)).toMatchTypeOf<number>();
+	// @ts-ignore
+	expectTypeOf(get(obj, 'nested.asdfasdf')).toMatchTypeOf<never>();
+	expectTypeOf(get(obj, 'deeplvl1[1].deeplvl2.deeplvl3[88].deeplvl4.value')).toMatchTypeOf<RegExp>();
+	// @ts-ignore
+	expectTypeOf(get(obj, 'deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value')).toMatchTypeOf<never>();
+	expectTypeOf(get(obj, 'deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value', obj)).toMatchTypeOf<TestClass>();
+	expectTypeOf(get(obj, 'nested["dd"]', '')).toMatchTypeOf<string>();
 });

package/src/objects/get.ts

@@ -6,17 +6,17 @@ import { parseObjectPath, type ObjectKey } from './parseObjectPath';
  * {@link https://github.com/developit/dlv dlv}
  */
 export function get<O extends object, P extends ObjectKey, OrElse extends unknown>(
-  obj: O,
-  key: P | P[],
-  def?: OrElse,
+	obj: O,
+	key: P | P[],
+	def?: OrElse,
 ): ResolveObjectPathType<O, P, OrElse> {
-  const undef = undefined;
-  const path = parseObjectPath(key);
-  let out: any = obj;
-  for (const i of path) {
-    out = out ? out[i] : undef;
-  }
-  return out === undef ? def : out;
+	const undef = undefined;
+	const path = parseObjectPath(key);
+	let out: any = obj;
+	for (const i of path) {
+		out = out ? out[i] : undef;
+	}
+	return out === undef ? (def as any) : out;
 }
 
 /**
@@ -25,25 +25,25 @@ export function get<O extends object, P extends ObjectKey, OrElse extends unknow
  * {@link https://github.com/Pouja/typescript-deep-path-safe typescript-deep-path-safe}
  */
 export type ResolveObjectPathType<
-  ObjectType,
-  Path extends string | symbol | number,
-  OrElse,
+	ObjectType,
+	Path extends string | symbol | number,
+	OrElse,
 > = Path extends keyof ObjectType
-  ? ObjectType[Path]
-  : Path extends `${infer LeftSide}.${infer RightSide}`
-    ? LeftSide extends keyof ObjectType
-      ? ResolveObjectPathType<ObjectType[LeftSide], RightSide, OrElse>
-      : Path extends `${infer LeftSide}[${number}].${infer RightSide}`
-        ? LeftSide extends keyof ObjectType
-          ? ObjectType[LeftSide] extends Array<infer U>
-            ? ResolveObjectPathType<U, RightSide, OrElse>
-            : OrElse
-          : OrElse
-        : OrElse
-    : Path extends `${infer LeftSide}[${number}]`
-      ? LeftSide extends keyof ObjectType
-        ? ObjectType[LeftSide] extends Array<infer U>
-          ? U
-          : OrElse
-        : OrElse
-      : OrElse;
+	? ObjectType[Path]
+	: Path extends `${infer LeftSide}.${infer RightSide}`
+		? LeftSide extends keyof ObjectType
+			? ResolveObjectPathType<ObjectType[LeftSide], RightSide, OrElse>
+			: Path extends `${infer LeftSide}[${number}].${infer RightSide}`
+				? LeftSide extends keyof ObjectType
+					? ObjectType[LeftSide] extends Array<infer U>
+						? ResolveObjectPathType<U, RightSide, OrElse>
+						: OrElse
+					: OrElse
+				: OrElse
+		: Path extends `${infer LeftSide}[${number}]`
+			? LeftSide extends keyof ObjectType
+				? ObjectType[LeftSide] extends Array<infer U>
+					? U
+					: OrElse
+				: OrElse
+			: OrElse;

package/src/objects/merge/isMergeableObject.ts

@@ -1,17 +1,17 @@
 // https://github.com/TehShrike/is-mergeable-object/blob/master/index.js
 
 export function isMergeableObject(value: any) {
-  return isNonNullObject(value) && !isSpecial(value);
+	return isNonNullObject(value) && !isSpecial(value);
 }
 
 function isNonNullObject(value: any) {
-  return !!value && typeof value === 'object';
+	return !!value && typeof value === 'object';
 }
 
 function isSpecial(value: any) {
-  var stringValue = Object.prototype.toString.call(value);
+	var stringValue = Object.prototype.toString.call(value);
 
-  return stringValue === '[object RegExp]' || stringValue === '[object Date]' || isReactElement(value);
+	return stringValue === '[object RegExp]' || stringValue === '[object Date]' || isReactElement(value);
 }
 
 // see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
@@ -19,5 +19,5 @@ var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
 var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
 
 function isReactElement(value: any) {
-  return value.$$typeof === REACT_ELEMENT_TYPE;
+	return value.$$typeof === REACT_ELEMENT_TYPE;
 }