@thisisagile/easy 13.6.11 → 14.0.0

package/src/domain/Repo.ts

@@ -1,20 +1,4 @@
-import {
-  asList,
-  asPageList,
-  Constructor,
-  Exception,
-  FetchOptions,
-  Gateway,
-  Id,
-  isValidatable,
-  Json,
-  JsonValue,
-  Key,
-  List,
-  PageList,
-  Repository,
-  toJson,
-} from '../types';
+import { asList, Constructor, Exception, FetchOptions, Gateway, Id, isValidatable, Json, JsonValue, Key, List, PageList, Repository, toJson } from '../types';
 import { when } from '../validation';
 import { reject, resolve } from '../utils';
 import { Struct } from './Struct';
@@ -29,7 +13,7 @@ export class Repo<T extends Struct, Options = FetchOptions> extends Repository<T
   create = (item: T | Json): T => (isValidatable(item) ? item : new this.ctor(item));
 
   all(options?: Options): Promise<PageList<T>> {
-    return this.gateway.all(options).then(js => asPageList(this.ctor, js));
+    return this.gateway.all(options).then(js => js.map(i => new this.ctor(i)));
   }
 
   byId(id: Id): Promise<T> {
@@ -44,19 +28,19 @@ export class Repo<T extends Struct, Options = FetchOptions> extends Repository<T
   }
 
   byKey(key: Key, options?: Options): Promise<PageList<T>> {
-    return this.gateway.by('key', key, options).then(js => asPageList(this.ctor, js));
+    return this.gateway.by('key', key, options).then(js => js.map(i => new this.ctor(i)));
   }
 
   by(key: keyof T, value: JsonValue, options?: Options): Promise<PageList<T>> {
-    return this.gateway.by(key.toString(), value, options).then(js => asPageList(this.ctor, js));
+    return this.gateway.by(key.toString(), value, options).then(js => js.map(i => new this.ctor(i)));
   }
 
   search(q: JsonValue, options?: Options): Promise<PageList<T>> {
-    return this.gateway.search(q, options).then(js => asPageList(this.ctor, js));
+    return this.gateway.search(q, options).then(js => js.map(i => new this.ctor(i)));
   }
 
   filter(options?: Options): Promise<PageList<T>> {
-    return this.gateway.filter(options).then(js => asPageList(this.ctor, js));
+    return this.gateway.filter(options).then(js => js.map(i => new this.ctor(i)));
   }
 
   exists(id: Id): Promise<boolean> {

package/src/domain/Typo.ts

@@ -1,4 +1,4 @@
-import { Exception, FetchOptions, Gateway, Id, Json, JsonValue, Key, List, PageList, Repository, toList, toPageList } from '../types';
+import { Exception, FetchOptions, Gateway, Id, Json, JsonValue, Key, List, PageList, Repository } from '../types';
 import { when } from '../validation';
 import { View } from '../utils';
 
@@ -10,7 +10,7 @@ export class Typo<T, Options = FetchOptions> extends Repository<T, Options> {
   create = (j: Json): T => this.view.from(j);
 
   all(options?: Options): Promise<PageList<T>> {
-    return this.gateway.all(options).then(js => toPageList(js.map(j => this.create(j))));
+    return this.gateway.all(options).then(js => js.map(this.create));
   }
 
   byId(id: Id): Promise<T> {
@@ -21,23 +21,23 @@ export class Typo<T, Options = FetchOptions> extends Repository<T, Options> {
   }
 
   byIds(...ids: Id[]): Promise<List<T>> {
-    return this.gateway.byIds(...ids).then(js => toList(js.map(j => this.create(j))));
+    return this.gateway.byIds(...ids).then(js => js.map(this.create));
   }
 
   byKey(key: Key, options?: Options): Promise<PageList<T>> {
-    return this.gateway.by('key', key, options).then(js => toPageList(js.map(j => this.create(j))));
+    return this.gateway.by('key', key, options).then(js => js.map(this.create));
   }
 
   by(key: keyof T, value: JsonValue, options?: Options): Promise<PageList<T>> {
-    return this.gateway.by(key.toString(), value, options).then(js => toPageList(js.map(j => this.create(j))));
+    return this.gateway.by(key.toString(), value, options).then(js => js.map(this.create));
   }
 
   search(q: JsonValue, options?: Options): Promise<PageList<T>> {
-    return this.gateway.search(q, options).then(js => toPageList(js.map(j => this.create(j))));
+    return this.gateway.search(q, options).then(js => js.map(this.create));
   }
 
   filter(options?: Options): Promise<PageList<T>> {
-    return this.gateway.filter(options).then(js => toPageList(js.map(j => this.create(j))));
+    return this.gateway.filter(options).then(js => js.map(j => this.create(j)));
   }
 
   exists(id: Id): Promise<boolean> {

package/src/domain/enums/Country.ts

@@ -1,4 +1,4 @@
-import { Enum, Id, text } from '../../types';
+import { Enum, Id, Optional, text } from '../../types';
 
 export class Country extends Enum {
   static readonly AF = new Country('Afghanistan', 'AF');
@@ -255,6 +255,10 @@ export class Country extends Enum {
     super(name, id);
   }
 
+  static lookup(other: string): Optional<Country> {
+    return this.all<Country>().first(l => l.equals(other));
+  }
+
   equals<E extends Enum>(other: E | Id): other is E {
     return text(other).lower.trim.equals(this.lower);
   }

package/src/domain/enums/Locale.ts

@@ -1,4 +1,4 @@
-import { Enum, Id, text } from '../../types';
+import { Enum, Id, Optional, text } from '../../types';
 
 export class Locale extends Enum {
   static readonly AF = new Locale('af', 'Afrikaans');
@@ -569,6 +569,10 @@ export class Locale extends Enum {
     super(name, id);
   }
 
+  static lookup(other: string): Optional<Locale> {
+    return this.all<Locale>().first(l => l.equals(other));
+  }
+
   equals<E extends Enum>(other: E | Id): other is E {
     return text(other).lower.trim.equals(this.lower);
   }

package/src/domain/enums/UnitOfMeasurement.ts

@@ -3,7 +3,7 @@ import { Enum } from '../../types';
 export class UnitOfMeasurement extends Enum {
   static readonly MM = new UnitOfMeasurement('Millimeter', 'mm', 1);
   static readonly CM = new UnitOfMeasurement('Centimeter', 'cm', 10);
-  static readonly DM = new UnitOfMeasurement('Centimeter', 'cm', 100);
+  static readonly DM = new UnitOfMeasurement('Decimeter', 'dm', 100);
   static readonly M = new UnitOfMeasurement('Meter', 'm', 1000);
   static readonly KM = new UnitOfMeasurement('Kilometer', 'km', 1000000);
 

package/src/process/Search.ts

@@ -1,4 +1,4 @@
-import { choose, FetchOptions, Id, JsonValue, Key, PageList, Repository, toList } from '../types';
+import { choose, FetchOptions, Id, JsonValue, Key, List, PageList, Repository, toPageList } from '../types';
 import { resolve } from '../utils';
 import { Req } from '../resources';
 
@@ -9,7 +9,7 @@ export class Search<T, Options = FetchOptions> {
 
   byId = (id: Id): Promise<T> => this.repo.byId(id);
 
-  byIds = (...ids: Id[]): Promise<PageList<T>> => this.repo.byIds(...ids);
+  byIds = (...ids: Id[]): Promise<List<T>> => this.repo.byIds(...ids);
 
   byKey = (key: Key, options?: Options): Promise<PageList<T>> => this.repo.byKey(key, options);
 
@@ -21,7 +21,7 @@ export class Search<T, Options = FetchOptions> {
         q => q,
         q => this.repo.search(q, options)
       )
-      .else(() => resolve(toList<T>()));
+      .else(() => resolve(toPageList<T>()));
 
   filter = (options?: Options): Promise<PageList<T>> => this.repo.filter(options);
 

package/src/services/MappedRouteGateway.ts

@@ -1,30 +1,30 @@
-import {Api} from './Api';
-import {Func, Json, List, Optional, Uri} from '../types';
-import {Mapper} from '../utils';
-import {RouteGateway} from './RouteGateway';
-import {RequestOptions} from '../http';
+import { Api } from './Api';
+import { Func, Json, Optional, PageList, Uri } from '../types';
+import { Mapper } from '../utils';
+import { RouteGateway } from './RouteGateway';
+import { RequestOptions } from '../http';
 
 export class MappedRouteGateway extends RouteGateway {
-    constructor(readonly route: Func<Uri>, readonly routeId: Func<Uri>, readonly map = new Mapper(), readonly api: Api = new Api()) {
-        super(route, routeId, api);
-    }
+  constructor(readonly route: Func<Uri>, readonly routeId: Func<Uri>, readonly map = new Mapper(), readonly api: Api = new Api()) {
+    super(route, routeId, api);
+  }
 
-    get(uri: Uri, options?: RequestOptions): Promise<List<Json>> {
-        return super.get(uri, options).then(is => is.map(i => this.map.in(i)));
-    }
+  get(uri: Uri, options?: RequestOptions): Promise<PageList<Json>> {
+    return super.get(uri, options).then(is => is.map(i => this.map.in(i)));
+  }
 
-    getOne(uri: Uri, options?: RequestOptions): Promise<Optional<Json>> {
-        return super
-            .get(uri, options)
-            .then(is => is.first())
-            .then(i => this.map.in(i));
-    }
+  getOne(uri: Uri, options?: RequestOptions): Promise<Optional<Json>> {
+    return super
+      .get(uri, options)
+      .then(is => is.first())
+      .then(i => this.map.in(i));
+  }
 
-    add(item: Json): Promise<Json> {
-        return super.add(this.map.out(item));
-    }
+  add(item: Json): Promise<Json> {
+    return super.add(this.map.out(item));
+  }
 
-    update(item: Json): Promise<Json> {
-        return super.update(this.map.out(item));
-    }
+  update(item: Json): Promise<Json> {
+    return super.update(this.map.out(item));
+  }
 }

package/src/services/RouteGateway.ts

@@ -1,48 +1,48 @@
-import {Api, RouteOptions} from './Api';
-import {Func, Id, Json, JsonValue, Optional, PageList, Uri} from '../types';
-import {HttpStatus} from '../http';
-import {ApiGateway} from './ApiGateway';
+import { Api, RouteOptions } from './Api';
+import { Func, Id, Json, JsonValue, Optional, PageList, Uri } from '../types';
+import { HttpStatus } from '../http';
+import { ApiGateway } from './ApiGateway';
 
 export class RouteGateway extends ApiGateway {
-    constructor(readonly route: Func<Uri>, readonly routeId: Func<Uri>, readonly api: Api = new Api()) {
-        super(api);
-    }
-
-    all(options?: RouteOptions): Promise<PageList<Json>> {
-        return this.get(this.route(), options);
-    }
-
-    byId(id: Id, options?: RouteOptions): Promise<Optional<Json>> {
-        return this.getOne(this.routeId().id(id));
-    }
-
-    search(q: JsonValue, options?: RouteOptions): Promise<PageList<Json>> {
-        return this.get(this.route().query(q), options);
-    }
-
-    exists(id: Id, options?: RouteOptions): Promise<boolean> {
-        return this.get(this.routeId().id(id))
-            .then(r => r.length === 1)
-            .catch(r => (HttpStatus.NotFound.equals(r.status) ? false : Promise.reject(r)));
-    }
-
-    add(item: Json, options?: RouteOptions): Promise<Json> {
-        return this.post(this.route(), item, options);
-    }
-
-    filter(options?: RouteOptions): Promise<PageList<Json>> {
-        return this.postSearch(this.route(), options);
-    }
-
-    update(item: Json, options?: RouteOptions): Promise<Json> {
-        return this.patch(this.routeId().id(item.id), item, options);
-    }
-
-    upsert(item: Json, options?: RouteOptions): Promise<Json> {
-        return this.put(this.routeId().id(item.id), item, options);
-    }
-
-    remove(id: Id, options?: RouteOptions): Promise<boolean> {
-        return this.delete(this.routeId().id(id), options);
-    }
+  constructor(readonly route: Func<Uri>, readonly routeId: Func<Uri>, readonly api: Api = new Api()) {
+    super(api);
+  }
+
+  all(options?: RouteOptions): Promise<PageList<Json>> {
+    return this.get(this.route(), options);
+  }
+
+  byId(id: Id, options?: RouteOptions): Promise<Optional<Json>> {
+    return this.getOne(this.routeId().id(id));
+  }
+
+  search(q: JsonValue, options?: RouteOptions): Promise<PageList<Json>> {
+    return this.get(this.route().query(q), options);
+  }
+
+  exists(id: Id, options?: RouteOptions): Promise<boolean> {
+    return this.get(this.routeId().id(id))
+      .then(r => r.length === 1)
+      .catch(r => (HttpStatus.NotFound.equals(r.status) ? false : Promise.reject(r)));
+  }
+
+  add(item: Json, options?: RouteOptions): Promise<Json> {
+    return this.post(this.route(), item, options);
+  }
+
+  filter(options?: RouteOptions): Promise<PageList<Json>> {
+    return this.postSearch(this.route(), options);
+  }
+
+  update(item: Json, options?: RouteOptions): Promise<Json> {
+    return this.patch(this.routeId().id(item.id), item, options);
+  }
+
+  upsert(item: Json, options?: RouteOptions): Promise<Json> {
+    return this.put(this.routeId().id(item.id), item, options);
+  }
+
+  remove(id: Id, options?: RouteOptions): Promise<boolean> {
+    return this.delete(this.routeId().id(id), options);
+  }
 }

package/src/services/ViewRouteGateway.ts

@@ -1,38 +1,38 @@
-import {Api} from './Api';
-import {Func, Json, List, Optional, Uri} from '../types';
-import {view} from '../utils';
-import {RouteGateway} from './RouteGateway';
-import {RequestOptions} from '../http';
+import { Api } from './Api';
+import { Func, Json, Optional, PageList, Uri } from '../types';
+import { view } from '../utils';
+import { RouteGateway } from './RouteGateway';
+import { RequestOptions } from '../http';
 
 export class ViewRouteGateway extends RouteGateway {
-    constructor(
-        readonly route: Func<Uri>,
-        readonly routeId: Func<Uri>,
-        readonly views = {
-            in: view({}).fromSource,
-            out: view({}).fromSource,
-        },
-        readonly api: Api = new Api()
-    ) {
-        super(route, routeId, api);
-    }
+  constructor(
+    readonly route: Func<Uri>,
+    readonly routeId: Func<Uri>,
+    readonly views = {
+      in: view({}).fromSource,
+      out: view({}).fromSource,
+    },
+    readonly api: Api = new Api()
+  ) {
+    super(route, routeId, api);
+  }
 
-    get(uri: Uri, options?: RequestOptions): Promise<List<Json>> {
-        return super.get(uri, options).then(is => is.map(i => this.views.in.from(i)));
-    }
+  get(uri: Uri, options?: RequestOptions): Promise<PageList<Json>> {
+    return super.get(uri, options).then(is => is.map(i => this.views.in.from(i)));
+  }
 
-    getOne(uri: Uri, options?: RequestOptions): Promise<Optional<Json>> {
-        return super
-            .get(uri, options)
-            .then(is => is.first())
-            .then(i => this.views.in.from(i));
-    }
+  getOne(uri: Uri, options?: RequestOptions): Promise<Optional<Json>> {
+    return super
+      .get(uri, options)
+      .then(is => is.first())
+      .then(i => this.views.in.from(i));
+  }
 
-    add(item: Json): Promise<Json> {
-        return super.add(this.views.out.from(item));
-    }
+  add(item: Json): Promise<Json> {
+    return super.add(this.views.out.from(item));
+  }
 
-    update(item: Json): Promise<Json> {
-        return super.update(this.views.out.from(item));
-    }
+  update(item: Json): Promise<Json> {
+    return super.update(this.views.out.from(item));
+  }
 }

package/src/sql/TableGateway.ts

@@ -1,4 +1,4 @@
-import { Gateway, Id, isDefined, Json, List, Optional, PageOptions } from '../types';
+import { Gateway, Id, isDefined, Json, Optional, PageList, PageOptions, toPageList } from '../types';
 import { QueryProvider } from '../data';
 import { when } from '../validation';
 import { ifDefined } from '../utils';
@@ -13,10 +13,15 @@ export class TableGateway<T extends Table> extends Gateway<PageOptions> {
 
   protected provide = ({ provider }: TableOptions = {}): QueryProvider => provider ?? this.provider;
 
-  all(options?: TableOptions): Promise<List<Json>> {
+  all(options?: TableOptions): Promise<PageList<Json>> {
     return this.provide(options)
       .query(this.table.select())
-      .then(js => js.map(j => this.table.in(j)));
+      .then(js =>
+        toPageList(
+          js.map(j => this.table.in(j)),
+          options
+        )
+      );
   }
 
   byId(id: Id, options?: TableOptions): Promise<Optional<Json>> {

package/src/types/Enum.ts

@@ -1,5 +1,5 @@
 import { Id } from './Id';
-import { List } from './List';
+import { List, toList } from './List';
 import { isAn } from './IsA';
 import { meta } from './Meta';
 import { isDefined } from './Is';
@@ -16,9 +16,11 @@ export abstract class Enum implements Validatable {
   }
 
   static all<E extends Enum>(): List<E> {
-    return meta(this)
-      .values<E>()
-      .filter((e: unknown) => isEnum(e));
+    return meta(this.allTuple<E>()).values<E>();
+  }
+
+  protected static allTuple<E extends Enum>(): Record<Id, E> {
+    return meta(this).get(`all-${this.name}`) ?? meta(this).set(`all-${this.name}`, meta(this).values<E>().filter(isEnum).toObject('id'));
   }
 
   static filter<E extends Enum>(p: (value: E, index: number, array: E[]) => unknown, params?: unknown): List<E> {
@@ -29,12 +31,12 @@ export abstract class Enum implements Validatable {
     return this.all<E>().first(p, params);
   }
 
-  static byIds<E extends Enum>(ids?: Id[]): List<E> {
-    return this.filter(e => ids?.some(i => e.equals(i)));
+  static byIds<E extends Enum>(ids: Id[] = []): List<E> {
+    return toList(ids).mapDefined(id => this.byId<E>(id)).distinct();
   }
 
   static byId<E extends Enum>(id: Id, alt?: Get<E, unknown>): E {
-    return this.first(e => e.equals(id)) ?? ofGet(alt);
+    return this.allTuple<E>()[id] ?? ofGet(alt);
   }
 
   equals<E extends Enum>(other: E | Id): other is E {

package/src/types/List.ts

@@ -11,9 +11,13 @@ import { meta } from './Meta';
 import { Optional } from './Types';
 
 export class List<T = unknown> extends Array<T> {
-  asc = (p: GetProperty<T, any>): List<T> => this.sort((e1, e2) => (ofProperty(e1, p) > ofProperty(e2, p) ? 1 : -1));
+  asc(p: GetProperty<T, any>): List<T> {
+    return this.sort((e1, e2) => (ofProperty(e1, p) > ofProperty(e2, p) ? 1 : -1));
+  }
 
-  desc = (p: GetProperty<T, any>): List<T> => this.sort((e1, e2) => (ofProperty(e1, p) < ofProperty(e2, p) ? 1 : -1));
+  desc(p: GetProperty<T, any>): List<T> {
+    return this.sort((e1, e2) => (ofProperty(e1, p) < ofProperty(e2, p) ? 1 : -1));
+  }
 
   first = (p?: (value: T, index: number, array: T[]) => unknown, params?: unknown): T => (p ? this.find(p, params) : this[0]) as T;
 
@@ -31,13 +35,21 @@ export class List<T = unknown> extends Array<T> {
 
   overlaps = (...items: ArrayLike<T>): boolean => toList<T>(...items).some(i => this.some(t => i === t));
 
-  diff = (others: ArrayLike<T>): List<T> => this.filter(i => !others.includes(i));
+  diff(others: ArrayLike<T>): List<T> {
+    return this.filter(i => !others.includes(i));
+  }
 
-  diffByKey = (others: ArrayLike<T>, key: keyof T): List<T> => this.filter((i: any) => !others.some((o: any) => o[key] === i[key]));
+  diffByKey(others: ArrayLike<T>, key: keyof T): List<T> {
+    return this.filter((i: any) => !others.some((o: any) => o[key] === i[key]));
+  }
 
-  intersect = (others: ArrayLike<T>): List<T> => this.filter(i => others.includes(i));
+  intersect(others: ArrayLike<T>): List<T> {
+    return this.filter(i => others.includes(i));
+  }
 
-  intersectByKey = (others: ArrayLike<T>, key: keyof T): List<T> => this.filter((i: any) => others.some((o: any) => o[key] === i[key]));
+  intersectByKey(others: ArrayLike<T>, key: keyof T): List<T> {
+    return this.filter((i: any) => others.some((o: any) => o[key] === i[key]));
+  }
 
   toJSON = (): Json[] =>
     this.reduce((a, i) => {
@@ -45,49 +57,82 @@ export class List<T = unknown> extends Array<T> {
       return a;
     }, new Array<Json>());
 
-  map = <U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): List<U> => toList<U>(super.map(f, params));
+  map<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): List<U> {
+    return toList<U>(super.map(f, params));
+  }
 
-  flatMap = <U, This = unknown>(f: (this: This, value: T, index: number, array: T[]) => ReadonlyArray<U> | U, params?: This): List<U> =>
-    toList<U>(super.flatMap(f, params));
+  flatMap<U, This = unknown>(f: (this: This, value: T, index: number, array: T[]) => ReadonlyArray<U> | U, params?: This): List<U> {
+    return toList<U>(super.flatMap(f, params));
+  }
 
-  mapDefined = <U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): List<NonNullable<U>> => this.map(f, params).defined();
+  mapDefined<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): List<NonNullable<U>> {
+    return this.map(f, params).defined();
+  }
 
-  mapAsync = (f: (i: T) => Promise<T>): Promise<List<T>> => Promise.all(super.map(e => f(e))).then(a => toList<T>(a));
+  mapAsync(f: (i: T) => Promise<T>): Promise<List<T>> {
+    return Promise.all(super.map(e => f(e))).then(a => toList<T>(a));
+  }
 
-  distinct = (): List<T> => this.filter((i, index) => this.indexOf(i) === index);
+  distinct(): List<T> {
+    return this.filter((i, index) => this.indexOf(i) === index);
+  }
 
-  distinctByKey = (key: keyof T): List<T> => meta(this.toObject(key)).values();
+  distinctByKey(key: keyof T): List<T> {
+    return meta(this.toObject(key)).values();
+  }
 
-  filter = (p: (value: T, index: number, array: T[]) => unknown, params?: unknown): List<T> => toList<T>(super.filter(p, params));
+  filter(p: (value: T, index: number, array: T[]) => unknown, params?: unknown): List<T> {
+    return toList<T>(super.filter(p, params));
+  }
 
   sum = (p: (t: T) => number): number => this.reduce((sum: number, i) => sum + p(i), 0);
 
   byId = (id: Id): T => this.first(i => asString((i as any).id) === asString(id));
 
-  add = (...items: (T | T[])[]): this => {
+  add = (...items: ArrayLike<T>): this => {
     super.push(...toArray(...items));
     return this;
   };
 
-  remove = (item: T): List<T> => {
+  concat(...items: ConcatArray<T>[]): List<T>;
+  concat(...items: (T | ConcatArray<T>)[]): List<T>;
+  concat(...items: (T | ConcatArray<T>)[]): List<T> {
+    return toList<T>(super.concat(...items));
+  }
+
+  reverse(): List<T> {
+    return toList<T>(super.reverse());
+  }
+
+  splice(start: number, deleteCount?: number): List<T>;
+  splice(start: number, deleteCount: number, ...items: T[]): List<T>;
+  splice(start: number, deleteCount: number, ...items: T[]): List<T> {
+    return toList<T>(super.splice(start, deleteCount, ...items));
+  }
+
+  remove(item: T): List<T> {
     const index = this.indexOf(item);
     if (index > -1) {
       this.splice(index, 1);
     }
     return this;
-  };
+  }
 
-  replace = (key: keyof T, item: T): List<T> => {
+  replace(key: keyof T, item: T): List<T> {
     tryTo(() => item[key])
       .map(k => this.findIndex(i => i[key] === k))
       .filter(i => i > -1)
       .map(i => (this[i] = item));
     return this;
-  };
+  }
 
-  switch = (item: T): List<T> => (this.includes(item) ? this.remove(item) : this.add(item));
+  switch(item: T): List<T> {
+    return this.includes(item) ? this.remove(item) : this.add(item);
+  }
 
-  defined = (): List<NonNullable<T>> => this.reduce((l, v) => (isDefined(v) ? l.add(v) : l), toList<NonNullable<T>>());
+  defined(): List<NonNullable<T>> {
+    return this.reduce((l, v) => (isDefined(v) ? l.add(v) : l), toList<NonNullable<T>>());
+  }
 
   toObject = (key: keyof T, options: { deleteKey?: boolean } = {}): Record<string | number | symbol, T> =>
     this.reduce((o: any, i) => {
@@ -104,7 +149,9 @@ export class List<T = unknown> extends Array<T> {
       return a;
     }, {} as Record<string | number | symbol, List<T>>);
 
-  orElse = (...alt: ArrayLike<T>): Optional<List<T>> => (!isEmpty(this) ? this : !isEmpty(...alt) ? toList<T>(...alt) : undefined);
+  orElse(...alt: ArrayLike<T>): Optional<List<T>> {
+    return !isEmpty(this) ? this : !isEmpty(...alt) ? toList<T>(...alt) : undefined;
+  }
 
   weave = (insertFrom: T[], interval: number): this => {
     for (let i = interval, n = 0; i <= this.length && n < insertFrom.length; i += interval + 1) {