@wener/utils 1.1.13 → 1.1.15

package/src/libs/ms.test.ts

@@ -0,0 +1,311 @@
+import { describe, expect, it } from 'vitest';
+import ms from './ms';
+
+describe('ms(string)', () => {
+  it('should not throw an error', () => {
+    expect(() => {
+      ms('1m');
+    }).not.toThrowError();
+  });
+
+  it('should preserve ms', () => {
+    expect(ms('100')).toBe(100);
+  });
+
+  it('should convert from m to ms', () => {
+    expect(ms('1m')).toBe(60000);
+  });
+
+  it('should convert from h to ms', () => {
+    expect(ms('1h')).toBe(3600000);
+  });
+
+  it('should convert d to ms', () => {
+    expect(ms('2d')).toBe(172800000);
+  });
+
+  it('should convert w to ms', () => {
+    expect(ms('3w')).toBe(1814400000);
+  });
+
+  it('should convert s to ms', () => {
+    expect(ms('1s')).toBe(1000);
+  });
+
+  it('should convert ms to ms', () => {
+    expect(ms('100ms')).toBe(100);
+  });
+
+  it('should convert y to ms', () => {
+    expect(ms('1y')).toBe(31557600000);
+  });
+
+  it('should work with decimals', () => {
+    expect(ms('1.5h')).toBe(5400000);
+  });
+
+  it('should work with multiple spaces', () => {
+    expect(ms('1   s')).toBe(1000);
+  });
+
+  it('should return NaN if invalid', () => {
+    // @ts-expect-error - We expect this to fail.
+    expect(isNaN(ms('☃'))).toBe(true);
+    // @ts-expect-error - We expect this to fail.
+    expect(isNaN(ms('10-.5'))).toBe(true);
+    // @ts-expect-error - We expect this to fail.
+    expect(isNaN(ms('ms'))).toBe(true);
+  });
+
+  it('should be case-insensitive', () => {
+    expect(ms('1.5H')).toBe(5400000);
+  });
+
+  it('should work with numbers starting with .', () => {
+    expect(ms('.5ms')).toBe(0.5);
+  });
+
+  it('should work with negative integers', () => {
+    expect(ms('-100ms')).toBe(-100);
+  });
+
+  it('should work with negative decimals', () => {
+    expect(ms('-1.5h')).toBe(-5400000);
+    expect(ms('-10.5h')).toBe(-37800000);
+  });
+
+  it('should work with negative decimals starting with "."', () => {
+    expect(ms('-.5h')).toBe(-1800000);
+  });
+});
+
+// long strings
+
+describe('ms(long string)', () => {
+  it('should not throw an error', () => {
+    expect(() => {
+      ms('53 milliseconds');
+    }).not.toThrowError();
+  });
+
+  it('should convert milliseconds to ms', () => {
+    expect(ms('53 milliseconds')).toBe(53);
+  });
+
+  it('should convert msecs to ms', () => {
+    expect(ms('17 msecs')).toBe(17);
+  });
+
+  it('should convert sec to ms', () => {
+    expect(ms('1 sec')).toBe(1000);
+  });
+
+  it('should convert from min to ms', () => {
+    expect(ms('1 min')).toBe(60000);
+  });
+
+  it('should convert from hr to ms', () => {
+    expect(ms('1 hr')).toBe(3600000);
+  });
+
+  it('should convert days to ms', () => {
+    expect(ms('2 days')).toBe(172800000);
+  });
+
+  it('should convert weeks to ms', () => {
+    expect(ms('1 week')).toBe(604800000);
+  });
+
+  it('should convert years to ms', () => {
+    expect(ms('1 year')).toBe(31557600000);
+  });
+
+  it('should work with decimals', () => {
+    expect(ms('1.5 hours')).toBe(5400000);
+  });
+
+  it('should work with negative integers', () => {
+    expect(ms('-100 milliseconds')).toBe(-100);
+  });
+
+  it('should work with negative decimals', () => {
+    expect(ms('-1.5 hours')).toBe(-5400000);
+  });
+
+  it('should work with negative decimals starting with "."', () => {
+    expect(ms('-.5 hr')).toBe(-1800000);
+  });
+});
+
+// numbers
+
+describe('ms(number, { long: true })', () => {
+  it('should not throw an error', () => {
+    expect(() => {
+      ms(500, { long: true });
+    }).not.toThrowError();
+  });
+
+  it('should support milliseconds', () => {
+    expect(ms(500, { long: true })).toBe('500 ms');
+
+    expect(ms(-500, { long: true })).toBe('-500 ms');
+  });
+
+  it('should support seconds', () => {
+    expect(ms(1000, { long: true })).toBe('1 second');
+    expect(ms(1200, { long: true })).toBe('1 second');
+    expect(ms(10000, { long: true })).toBe('10 seconds');
+
+    expect(ms(-1000, { long: true })).toBe('-1 second');
+    expect(ms(-1200, { long: true })).toBe('-1 second');
+    expect(ms(-10000, { long: true })).toBe('-10 seconds');
+  });
+
+  it('should support minutes', () => {
+    expect(ms(60 * 1000, { long: true })).toBe('1 minute');
+    expect(ms(60 * 1200, { long: true })).toBe('1 minute');
+    expect(ms(60 * 10000, { long: true })).toBe('10 minutes');
+
+    expect(ms(-1 * 60 * 1000, { long: true })).toBe('-1 minute');
+    expect(ms(-1 * 60 * 1200, { long: true })).toBe('-1 minute');
+    expect(ms(-1 * 60 * 10000, { long: true })).toBe('-10 minutes');
+  });
+
+  it('should support hours', () => {
+    expect(ms(60 * 60 * 1000, { long: true })).toBe('1 hour');
+    expect(ms(60 * 60 * 1200, { long: true })).toBe('1 hour');
+    expect(ms(60 * 60 * 10000, { long: true })).toBe('10 hours');
+
+    expect(ms(-1 * 60 * 60 * 1000, { long: true })).toBe('-1 hour');
+    expect(ms(-1 * 60 * 60 * 1200, { long: true })).toBe('-1 hour');
+    expect(ms(-1 * 60 * 60 * 10000, { long: true })).toBe('-10 hours');
+  });
+
+  it('should support days', () => {
+    expect(ms(24 * 60 * 60 * 1000, { long: true })).toBe('1 day');
+    expect(ms(24 * 60 * 60 * 1200, { long: true })).toBe('1 day');
+    expect(ms(24 * 60 * 60 * 10000, { long: true })).toBe('10 days');
+
+    expect(ms(-1 * 24 * 60 * 60 * 1000, { long: true })).toBe('-1 day');
+    expect(ms(-1 * 24 * 60 * 60 * 1200, { long: true })).toBe('-1 day');
+    expect(ms(-1 * 24 * 60 * 60 * 10000, { long: true })).toBe('-10 days');
+  });
+
+  it('should round', () => {
+    expect(ms(234234234, { long: true })).toBe('3 days');
+
+    expect(ms(-234234234, { long: true })).toBe('-3 days');
+  });
+});
+
+// numbers
+
+describe('ms(number)', () => {
+  it('should not throw an error', () => {
+    expect(() => {
+      ms(500);
+    }).not.toThrowError();
+  });
+
+  it('should support milliseconds', () => {
+    expect(ms(500)).toBe('500ms');
+
+    expect(ms(-500)).toBe('-500ms');
+  });
+
+  it('should support seconds', () => {
+    expect(ms(1000)).toBe('1s');
+    expect(ms(10000)).toBe('10s');
+
+    expect(ms(-1000)).toBe('-1s');
+    expect(ms(-10000)).toBe('-10s');
+  });
+
+  it('should support minutes', () => {
+    expect(ms(60 * 1000)).toBe('1m');
+    expect(ms(60 * 10000)).toBe('10m');
+
+    expect(ms(-1 * 60 * 1000)).toBe('-1m');
+    expect(ms(-1 * 60 * 10000)).toBe('-10m');
+  });
+
+  it('should support hours', () => {
+    expect(ms(60 * 60 * 1000)).toBe('1h');
+    expect(ms(60 * 60 * 10000)).toBe('10h');
+
+    expect(ms(-1 * 60 * 60 * 1000)).toBe('-1h');
+    expect(ms(-1 * 60 * 60 * 10000)).toBe('-10h');
+  });
+
+  it('should support days', () => {
+    expect(ms(24 * 60 * 60 * 1000)).toBe('1d');
+    expect(ms(24 * 60 * 60 * 10000)).toBe('10d');
+
+    expect(ms(-1 * 24 * 60 * 60 * 1000)).toBe('-1d');
+    expect(ms(-1 * 24 * 60 * 60 * 10000)).toBe('-10d');
+  });
+
+  it('should round', () => {
+    expect(ms(234234234)).toBe('3d');
+
+    expect(ms(-234234234)).toBe('-3d');
+  });
+});
+
+// invalid inputs
+
+describe('ms(invalid inputs)', () => {
+  it('should throw an error, when ms("")', () => {
+    expect(() => {
+      // @ts-expect-error - We expect this to throw.
+      ms('');
+    }).toThrowError();
+  });
+
+  it('should throw an error, when ms(undefined)', () => {
+    expect(() => {
+      // @ts-expect-error - We expect this to throw.
+      ms(undefined);
+    }).toThrowError();
+  });
+
+  it('should throw an error, when ms(null)', () => {
+    expect(() => {
+      // @ts-expect-error - We expect this to throw.
+      ms(null);
+    }).toThrowError();
+  });
+
+  it('should throw an error, when ms([])', () => {
+    expect(() => {
+      // @ts-expect-error - We expect this to throw.
+      ms([]);
+    }).toThrowError();
+  });
+
+  it('should throw an error, when ms({})', () => {
+    expect(() => {
+      // @ts-expect-error - We expect this to throw.
+      ms({});
+    }).toThrowError();
+  });
+
+  it('should throw an error, when ms(NaN)', () => {
+    expect(() => {
+      ms(NaN);
+    }).toThrowError();
+  });
+
+  it('should throw an error, when ms(Infinity)', () => {
+    expect(() => {
+      ms(Infinity);
+    }).toThrowError();
+  });
+
+  it('should throw an error, when ms(-Infinity)', () => {
+    expect(() => {
+      ms(-Infinity);
+    }).toThrowError();
+  });
+});

package/src/logging/createLogger.ts

@@ -12,11 +12,21 @@ export function createLogger(
   context: object = {},
 ): LoggerWithChild {
   return {
-    trace: (...values) => { write({ ...context, level: 'trace', values }); },
-    debug: (...values) => { write({ ...context, level: 'debug', values }); },
-    info: (...values) => { write({ ...context, level: 'info', values }); },
-    warn: (...values) => { write({ ...context, level: 'warn', values }); },
-    error: (...values) => { write({ ...context, level: 'error', values }); },
+    trace: (...values) => {
+      write({ ...context, level: 'trace', values });
+    },
+    debug: (...values) => {
+      write({ ...context, level: 'debug', values });
+    },
+    info: (...values) => {
+      write({ ...context, level: 'info', values });
+    },
+    warn: (...values) => {
+      write({ ...context, level: 'warn', values });
+    },
+    error: (...values) => {
+      write({ ...context, level: 'error', values });
+    },
     child: (ctx) => createLogger(write, { ...context, ...ctx }),
   };
 }

package/src/logging/logger.test.ts

@@ -1,16 +1,16 @@
-import test from 'ava';
+import { test, expect } from 'vitest';
 import { createChildLogger } from './createChildLogger';
 import { createLogger } from './createLogger';
 
-test('logger', (t) => {
+test('logger', () => {
   {
     const logs: any[] = [];
     const base = createLogger((o) => logs.push(o));
     const l = createChildLogger(base, { c: 'test' });
     l.info('hello');
-    t.deepEqual(logs.shift(), { level: 'info', values: ['hello'], c: 'test' });
+    expect(logs.shift()).toEqual({ level: 'info', values: ['hello'], c: 'test' });
     l.child({ m: 1 }).trace('trace');
-    t.deepEqual(logs.shift(), { level: 'trace', values: ['trace'], c: 'test', m: 1 });
+    expect(logs.shift()).toEqual({ level: 'trace', values: ['trace'], c: 'test', m: 1 });
   }
   createChildLogger(console, { c: 'test' }).info('hello');
   {
@@ -18,18 +18,18 @@ test('logger', (t) => {
     const l = createLogger(
       (o) => {
         pass++;
-        t.log(`${o.level}: [${[o.m, o.c].filter(Boolean).join('.') || 'default'}]`, ...o.values);
+        console.log(`${o.level}: [${[o.m, o.c].filter(Boolean).join('.') || 'default'}]`, ...o.values);
       },
       {
         m: 'Root',
       },
     );
     l.info('nice');
-    t.is(pass, 1);
+    expect(pass).toBe(1);
     l.child({}).info('nice 2');
-    t.is(pass, 2);
+    expect(pass).toBe(2);
     createChildLogger(l, { m: 'Child' }).info('nice 3');
-    t.is(pass, 3);
+    expect(pass).toBe(3);
 
     createLogger().child({ name: 'wener' }).info({ x: 1 }, 'Nice');
   }

package/src/modules/parseModuleId.test.ts

@@ -1,7 +1,7 @@
-import test from 'ava';
+import { test, expect } from 'vitest';
 import { parseModuleId } from './parseModuleId';
 
-test('parseModuleId', (t) => {
+test('parseModuleId', () => {
   const tests = {
     '@wener/reaction': {
       id: `@wener/reaction@latest`,
@@ -68,6 +68,6 @@ test('parseModuleId', (t) => {
     },
   };
   for (const [k, v] of Object.entries(tests)) {
-    t.deepEqual(parseModuleId(k), v);
+    expect(parseModuleId(k)).toStrictEqual(v);
   }
 });

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

@@ -1,4 +1,4 @@
-import { expectType } from 'tsd';
+import { expectTypeOf, test } from 'vitest';
 import { get } from './get';
 
 interface TestClass {
@@ -27,25 +27,33 @@ interface TestClass {
     };
   }[];
 }
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-const obj = {} as TestClass;
 
-expectType<number>(get(obj, 'nested.a', null));
-expectType<string>(get(obj, 'normal', null));
-expectType<number>(get(obj, 'nested.a'));
-expectType<boolean>(get(obj, 'nested.b.c'));
-expectType<number[]>(get(obj, 'arr'));
-expectType<number>(get(obj, 'arr[13]'));
-expectType<number>(get(obj, 'arr.13'));
-expectType<null>(get(obj, 'nestedArr[3].other'));
-expectType<string[]>(get(obj, 'deep.deep'));
-expectType<string>(get(obj, 'deep.arr[333]'));
-expectType<number>(get(obj, 'deep.arr[333].length'));
-expectType<boolean>(get(obj, 'nested["b"]["c"]'));
-expectType<never>(get(obj, ''));
-expectType<number>(get(obj, '', 3));
-expectType<never>(get(obj, 'nested.asdfasdf'));
-expectType<RegExp>(get(obj, 'deeplvl1[1].deeplvl2.deeplvl3[88].deeplvl4.value'));
-expectType<never>(get(obj, 'deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value'));
-expectType<TestClass>(get(obj, 'deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value', obj));
-expectType<string>(get(obj, 'nested["dd"]', ''));
+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>();
+});

package/src/objects/get.ts

@@ -1,4 +1,4 @@
-import type { ObjectKey} from './parseObjectPath';
+import type { ObjectKey } from './parseObjectPath';
 import { parseObjectPath } from './parseObjectPath';
 
 /**

package/src/objects/parseObjectPath.test.ts

@@ -1,7 +1,7 @@
-import test from 'ava';
+import { test, expect } from 'vitest';
 import { parseObjectPath } from './parseObjectPath';
 
-test('parseObjectPath', (t) => {
+test('parseObjectPath', () => {
   for (const [k, v] of [
     ['a.b.c', ['a', 'b', 'c']],
     ['a[1].c', ['a', '1', 'c']],
@@ -13,6 +13,6 @@ test('parseObjectPath', (t) => {
     [Symbol.toStringTag, [Symbol.toStringTag]],
     [[Symbol.toStringTag], [Symbol.toStringTag]],
   ]) {
-    t.deepEqual(parseObjectPath(k), v);
+    expect(parseObjectPath(k)).toEqual(v);
   }
 });