feat(micro-dash): remove dependency on the utility-types library

package.json

@@ -30,7 +30,6 @@
     "@angular/router": "^17.0.0",
     "rxjs": "~7.8.0",
     "tslib": "^2.3.0",
-    "utility-types": "~3.10.0",
     "zone.js": "~0.14.2"
   },
   "devDependencies": {

projects/micro-dash/ng-package.json

@@ -4,6 +4,5 @@
   "lib": {
     "entryFile": "src/public-api.ts",
     "flatModuleFile": "micro-dash"
-  },
-  "allowedNonPeerDependencies": ["utility-types"]
+  }
 }

projects/micro-dash/package.json

@@ -10,6 +10,6 @@
     "url": "https://github.com/simontonsoftware/s-libs.git",
     "directory": "projects/micro-dash"
   },
-  "dependencies": { "tslib": "^2.3.0", "utility-types": "^3.10.0" },
+  "dependencies": { "tslib": "^2.3.0" },
   "sideEffects": false
 }

projects/micro-dash/src/lib/array/compact.ts

@@ -1,4 +1,4 @@
-import { Falsey } from 'utility-types';
+import { Falsy } from '../interfaces';
 import { identity } from '../util';
 
 /**
@@ -8,7 +8,7 @@ import { identity } from '../util';
  * - Lodash: 113 bytes
  * - Micro-dash: 62 bytes
  */
-export function compact<T>(array: readonly T[]): Array<Exclude<T, Falsey>> {
+export function compact<T>(array: readonly T[]): Array<Exclude<T, Falsy>> {
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- not sure why this rule triggers
-  return array.filter(identity) as Array<Exclude<T, Falsey>>;
+  return array.filter(identity) as Array<Exclude<T, Falsy>>;
 }

projects/micro-dash/src/lib/interfaces.ts

@@ -1,10 +1,12 @@
+// aliases
 export type Nil = null | undefined;
 export type Primitive = boolean | number | string;
 export type Existent = Primitive | object;
+export type Falsy = '' | 0 | false | null | undefined;
 export type EmptyObject = Record<string, never>;
 export type ObjectWith<T> = Record<string, T>;
-export type StringifiedKey<T> = Cast<keyof T, string>;
 
+// iteratees
 export type ArrayIteratee<I, O> = (item: I, index: number) => O;
 export type ArrayNarrowingIteratee<O> = (item: any, index: number) => item is O;
 export type ObjectIteratee<T, O> = (
@@ -21,6 +23,7 @@ export type KeyNarrowingIteratee<I, O> = (
 ) => key is O;
 export type ValueIteratee<T, O> = (value: T) => O;
 
+// coercion
 export type Cast<I, O> = Exclude<I, O> extends never ? I : O;
 export type Narrow<I, O> = Extract<I, O> | Extract<O, I>;
 export type IfCouldBe<T1, T2, If, Else = never> = Narrow<T1, T2> extends never
@@ -32,22 +35,30 @@ export type IfIndexType<T, If, Else = never> = string extends T
   ? If
   : Else;
 
+// object parts
 type IndexKeys<T> = { [K in keyof T]: IfIndexType<K, K> }[keyof T];
 type NonIndexKeys<T> = { [K in keyof T]: IfIndexType<K, never, K> }[keyof T];
 export type PartialExceptIndexes<T> = {
   [K in NonIndexKeys<T>]?: T[K];
 } & { [K in IndexKeys<T>]: T[K] };
-
+export type StringifiedKey<T> = Cast<keyof T, string>;
 export type ValuesType<T> = T extends readonly []
   ? T[number]
   : T extends ArrayLike<any>
   ? T[number]
   : T extends object
   ? T[keyof T]
   : never;
+export type DeepPartial<T> = T extends Array<infer E>
+  ? Array<DeepPartial<E>>
+  : T extends object
+  ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : T | undefined;
 
+// misc
 export type Evaluate<T> = T extends infer I ? { [K in keyof I]: T[K] } : never;
 
+// very special-case
 export type Drop1Arg<T extends Function> = T extends (
   arg1: any,
   ...rest: infer A

projects/micro-dash/src/lib/lang/is-match.spec.ts

@@ -1,5 +1,4 @@
-import { Falsey } from 'utility-types';
-import { ObjectWith } from '../interfaces';
+import { Falsy, ObjectWith } from '../interfaces';
 import { isMatch } from './is-match';
 
 describe('isMatch()', () => {
@@ -102,7 +101,7 @@ describe('isMatch()', () => {
   });
 
   it('should return `true` when comparing an empty `source`', () => {
-    const object = { a: 1 } as any[] | Falsey | { a: 1 };
+    const object = { a: 1 } as any[] | Falsy | { a: 1 };
     expect(isMatch(object, [])).toBe(true);
     expect(isMatch(object, {})).toBe(true);
     expect(isMatch(object, null)).toBe(true);

projects/micro-dash/src/lib/lang/is-match.ts

@@ -1,5 +1,5 @@
-import { DeepPartial } from 'utility-types';
 import { every } from '../collection/every';
+import { DeepPartial } from '../interfaces';
 import { isEmpty } from './is-empty';
 
 /**

projects/micro-dash/src/lib/object/invoke.spec.ts

@@ -1,3 +1,6 @@
+import { staticTest } from '@s-libs/ng-dev';
+import { expectTypeOf } from 'expect-type';
+import { Nil } from '../interfaces';
 import { invoke } from './invoke';
 
 describe('invoke()', () => {
@@ -10,6 +13,106 @@ describe('invoke()', () => {
     expect(spy.calls.first().object).toBe(obj);
   });
 
+  it('has fancy typing', () => {
+    staticTest(() => {
+      //
+      // empty path
+      //
+
+      expectTypeOf(invoke({ a: () => 1 }, [])).toEqualTypeOf<undefined>();
+      expectTypeOf(
+        invoke({} as { a: () => string } | undefined, []),
+      ).toEqualTypeOf<undefined>();
+
+      //
+      // 1 element path
+      //
+
+      expectTypeOf(invoke({ a: () => 1 }, ['a'])).toEqualTypeOf<number>();
+      expectTypeOf(
+        invoke({ a: (a: boolean) => a }, ['a'], true),
+      ).toEqualTypeOf<boolean>();
+      expectTypeOf(invoke({} as { a?: () => string }, ['a'])).toEqualTypeOf<
+        string | undefined
+      >();
+      expectTypeOf(
+        invoke({} as Nil | { a: () => string }, ['a']),
+      ).toEqualTypeOf<string | undefined>();
+
+      //
+      // 2 element path
+      //
+
+      expectTypeOf(
+        invoke({ a: { b: () => 1 } }, ['a', 'b']),
+      ).toEqualTypeOf<number>();
+      expectTypeOf(
+        invoke({ a: { b: (a: boolean) => a } }, ['a', 'b'], true),
+      ).toEqualTypeOf<boolean>();
+      expectTypeOf(
+        invoke({} as { a: { b?: () => string } }, ['a', 'b']),
+      ).toEqualTypeOf<string | undefined>();
+      expectTypeOf(
+        invoke({} as { a?: { b: () => string } }, ['a', 'b']),
+      ).toEqualTypeOf<string | undefined>();
+      expectTypeOf(
+        invoke({} as Nil | { a: { b: () => string } }, ['a', 'b']),
+      ).toEqualTypeOf<string | undefined>();
+
+      //
+      // 3 element path
+      //
+
+      const path3: ['a', 'b', 'c'] = ['a', 'b', 'c'];
+      expectTypeOf(
+        invoke({ a: { b: { c: () => 1 } } }, path3),
+      ).toEqualTypeOf<number>();
+      expectTypeOf(
+        invoke({ a: { b: { c: (a: boolean) => a } } }, path3, true),
+      ).toEqualTypeOf<boolean>();
+      expectTypeOf(
+        invoke({} as { a: { b: { c?: () => string } } }, path3),
+      ).toEqualTypeOf<string | undefined>();
+      expectTypeOf(
+        invoke({} as { a: { b?: { c: () => string } } }, path3),
+      ).toEqualTypeOf<string | undefined>();
+      expectTypeOf(
+        invoke({} as { a?: { b: { c: () => string } } }, path3),
+      ).toEqualTypeOf<string | undefined>();
+      expectTypeOf(
+        invoke({} as Nil | { a: { b: { c: () => string } } }, path3),
+      ).toEqualTypeOf<string | undefined>();
+
+      // //
+      // // 4 element path
+      // //
+      //
+      // const path4: ["a", "b", "c", "d"] = ["a", "b", "c", "d"];
+      // // $ExpectType number
+      // invoke({ a: { b: { c: { d: () => 1 } } } }, path4);
+      // // $ExpectType boolean
+      // invoke({ a: { b: { c: { d: (a: boolean) => a } } } }, path4, true);
+      // // $ExpectType string | undefined
+      // invoke({} as { a: { b: { c: { d?: () => string } } } }, path4);
+      // // $ExpectType string | undefined
+      // invoke({} as { a: { b: { c?: { d: () => string } } } }, path4);
+      // // $ExpectType string | undefined
+      // invoke({} as { a: { b?: { c: { d: () => string } } } }, path4);
+      // // $ExpectType string | undefined
+      // invoke({} as { a?: { b: { c: { d: () => string } } } }, path4);
+      // // $ExpectType string | undefined
+      // invoke({} as { a: { b: { c: { d: () => string } } } } | Nil, path4);
+
+      //
+      // fallback: n element path
+      //
+
+      const pathN: string[] = ['a'];
+      // $ExpectType any
+      invoke({ a: () => 1 }, pathN);
+    });
+  });
+
   //
   // stolen from https://github.com/lodash/lodash
   //

projects/micro-dash/src/lib/object/invoke.ts

@@ -1,9 +1,9 @@
-import { NonUndefined } from 'utility-types';
 import { Existent, Nil } from '../interfaces';
 import { isFunction } from '../lang';
 import { get } from './get';
 
 type Fn = (...args: any[]) => any;
+type NonUndefined<T> = T extends undefined ? never : T;
 
 type Obj1<K1 extends PropertyKey, V> = { [key in K1]?: V };
 type Path1<

projects/ng-dev/src/lib/interfaces.ts

@@ -0,0 +1,3 @@
+export type ResolveType<F> = F extends (...args: any[]) => Promise<infer U>
+  ? U
+  : never;

projects/ng-dev/src/lib/spies/test-call.ts

@@ -1,6 +1,6 @@
 import { Deferred } from '@s-libs/js-core';
-import { PromiseType } from 'utility-types';
 import { AngularContext } from '../angular-context';
+import { ResolveType } from '../interfaces';
 
 /**
  * A mock method call that was made and is ready to be answered. This interface allows access to the underlying <code>jasmine.CallInfo</code>, and allows resolving or rejecting the asynchronous call's result.
@@ -10,14 +10,14 @@ export class TestCall<F extends jasmine.Func> {
   callInfo!: jasmine.CallInfo<F>;
 
   constructor(
-    private deferred: Deferred<PromiseType<ReturnType<F>>>,
+    private deferred: Deferred<ResolveType<F>>,
     private autoTick: boolean,
   ) {}
 
   /**
    * Resolve the call with the given value.
    */
-  flush(value: PromiseType<ReturnType<F>>): void {
+  flush(value: ResolveType<F>): void {
     this.deferred.resolve(value);
     this.maybeTick();
   }