@thisisagile/easy 13.6.11 → 13.6.12

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) {

package/src/types/PageList.ts

@@ -1,7 +1,12 @@
-import { isList, List, toList } from './List';
-import { Construct, ofConstruct, on } from './Constructor';
+import { isList, List } from './List';
+import { Construct, ofConstruct } from './Constructor';
 import { isA } from './IsA';
 import { PlainSort, Sort } from './Sort';
+import { GetProperty } from './Get';
+import { ArrayLike } from './Array';
+import { Optional } from './Types';
+import { isNumber } from './Is';
+import { choose } from './Case';
 
 export type FilterValue = { label?: string; value: any };
 export type Filter = { label?: string; field: string; shortField?: string; values: FilterValue[] };
@@ -14,21 +19,147 @@ export const toShortFilter = (field: string, shortField: string, value: any): Fi
 });
 
 export type PageOptions = { take?: number; skip?: number; sort?: Sort[]; sorts?: PlainSort; filters?: Filter[] };
-export type PageList<T> = List<T> & Omit<PageOptions, 'sort'> & { total?: number };
+
+export class PageList<T> extends List<T> {
+  private _take = 250;
+  private _skip = 0;
+  private _total?: number;
+  private _sorts?: PlainSort;
+  private _filters?: Filter[];
+
+  setPageOptions(options?: PageOptions & { total?: number }): this {
+    this._take = options?.take ?? 250;
+    this._skip = options?.skip ?? 0;
+    this._total = options?.total;
+    this._sorts = options?.sorts;
+    this._filters = options?.filters;
+    return this;
+  }
+
+  get take(): number {
+    return this._take;
+  }
+
+  get skip(): number {
+    return this._skip;
+  }
+
+  get total(): Optional<number> {
+    return this._total;
+  }
+
+  get sorts(): Optional<PlainSort> {
+    return this._sorts;
+  }
+
+  get filters(): Optional<Filter[]> {
+    return this._filters;
+  }
+
+  asc(p: GetProperty<T, any>): PageList<T> {
+    return toPageList(super.asc(p), this);
+  }
+
+  desc(p: GetProperty<T, any>): PageList<T> {
+    return toPageList(super.desc(p), this);
+  }
+
+  diff(others: ArrayLike<T>): PageList<T> {
+    return toPageList(super.diff(others), this);
+  }
+
+  diffByKey(others: ArrayLike<T>, key: keyof T): PageList<T> {
+    return toPageList(super.diffByKey(others, key), this);
+  }
+
+  intersect(others: ArrayLike<T>): PageList<T> {
+    return toPageList(super.intersect(others), this);
+  }
+
+  intersectByKey(others: ArrayLike<T>, key: keyof T): PageList<T> {
+    return toPageList(super.intersectByKey(others, key), this);
+  }
+
+  map<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): PageList<U> {
+    const items = super.map(f, params);
+    return toPageList(items, this);
+  }
+
+  flatMap<U, This = unknown>(f: (this: This, value: T, index: number, array: T[]) => ReadonlyArray<U> | U, params?: This): PageList<U> {
+    return toPageList(super.flatMap(f, params), this);
+  }
+
+  mapDefined<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): PageList<NonNullable<U>> {
+    return toPageList(super.mapDefined(f, params), this);
+  }
+
+  mapAsync(f: (i: T) => Promise<T>): Promise<PageList<T>> {
+    return super.mapAsync(f).then(r => toPageList(r, this));
+  }
+
+  distinct(): PageList<T> {
+    return toPageList(super.distinct(), this);
+  }
+
+  distinctByKey(key: keyof T): PageList<T> {
+    return toPageList(super.distinctByKey(key), this);
+  }
+
+  filter(p: (value: T, index: number, array: T[]) => unknown, params?: unknown): PageList<T> {
+    return toPageList(super.filter(p, params), this);
+  }
+
+  concat(...items: ConcatArray<T>[]): PageList<T>;
+  concat(...items: (T | ConcatArray<T>)[]): PageList<T>;
+  concat(...items: (T | ConcatArray<T>)[]): PageList<T> {
+    return toPageList(super.concat(...items), this);
+  }
+
+  reverse(): PageList<T> {
+    return toPageList(super.reverse(), this);
+  }
+
+  splice(start: number, deleteCount?: number): PageList<T>;
+  splice(start: number, deleteCount: number, ...items: T[]): PageList<T>;
+  splice(start: number, deleteCount: number, ...items: T[]): PageList<T> {
+    return toPageList(super.splice(start, deleteCount, ...items), this);
+  }
+
+  remove(item: T): PageList<T> {
+    return toPageList(super.remove(item), this);
+  }
+
+  replace(key: keyof T, item: T): PageList<T> {
+    return toPageList(super.replace(key, item), this);
+  }
+
+  switch(item: T): PageList<T> {
+    return toPageList(super.switch(item), this);
+  }
+
+  defined(): PageList<NonNullable<T>> {
+    return toPageList(super.defined(), this);
+  }
+
+  orElse(...alt: ArrayLike<T>): Optional<PageList<T>> {
+    return toPageList(super.orElse(...alt), this);
+  }
+
+  slice(start?: number, end?: number): PageList<T> {
+    return toPageList(super.slice(start, end), this);
+  }
+}
 
 export const isPageList = <T>(l?: unknown): l is PageList<T> => isList<T>(l) && isA(l, 'total');
 
-export const toPageList = <T>(items?: T[], options?: Omit<PageOptions, 'sort'> & { total?: number }): PageList<T> =>
-  on(toList<T>(...(items ?? [])) as PageList<T>, l => {
-    l.take = options?.take ?? 250;
-    l.skip = options?.skip ?? 0;
-    l.total = options?.total;
-    l.sorts = options?.sorts;
-    l.filters = options?.filters;
-  });
-
-export const asPageList = <T, U>(c: Construct<T>, items = toPageList<U>()): PageList<T> =>
-  toPageList<T>(
-    items.map(i => ofConstruct(c, i)),
-    items
-  );
+export const toPageList = <T>(items: T[] = [], options?: Omit<PageOptions, 'sort'> & { total?: number }): PageList<T> =>
+  choose(items)
+    .case(
+      i => i.length === 1 && isNumber(i[0]),
+      i => new PageList<T>().add(...i)
+    )
+    .else(i => new PageList<T>(...i))
+    .setPageOptions(options);
+
+/* @deprecated No longer needed as the PageList is now a class that extends from List, use the map function */
+export const asPageList = <T, U>(c: Construct<T>, items = toPageList<U>()): PageList<T> => items.map(i => ofConstruct(c, i));

package/src/utils/If.ts

@@ -1,6 +1,8 @@
-import {Construct, isDefined, isNotEmpty, isTrue, ofConstruct, Optional} from '../types';
+import { Construct, isDefined, isNotEmpty, isTrue, ofConstruct, Optional } from '../types';
 
 export const ifTrue = <T>(o: unknown, f: Construct<T>, alt?: Construct<T>): Optional<T> => (isTrue(o) ? ofConstruct(f, o) : ofConstruct(alt, o));
 export const ifFalse = <T>(o: unknown, f: Construct<T>, alt?: Construct<T>): Optional<T> => (!isTrue(o) ? ofConstruct(f, o) : ofConstruct(alt, o));
-export const ifDefined = <Out, In = unknown>(o: Optional<In>, f: Construct<Out, NonNullable<In>>, alt?: Construct<Out>): Optional<Out> => (isDefined(o) ? ofConstruct(f, o) : ofConstruct(alt));
-export const ifNotEmpty = <T>(o: unknown, f: Construct<T> = o => o, alt?: Construct<T>): Optional<T> => isNotEmpty(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
+export const ifDefined = <Out, In = unknown>(o: Optional<In>, f: Construct<Out, NonNullable<In>>, alt?: Construct<Out>): Optional<Out> =>
+  isDefined(o) ? ofConstruct(f, o) : ofConstruct(alt);
+export const ifNotEmpty = <T>(o: unknown, f: Construct<T> = o => o, alt?: Construct<T>): Optional<T> =>
+  isNotEmpty(o) ? ofConstruct(f, o) : ofConstruct(alt, o);

package/src/utils/View.ts

@@ -80,7 +80,11 @@ export class View<V = Json> {
   from<T = unknown>(source: T[]): V[];
   from<T = unknown>(source: T): V;
   from<T = unknown>(source: PageList<T> | List<T> | T[] | T): PageList<V> | List<V> | V[] | V {
-    if (isPageList(source)) return toPageList(source.map(s => this.reduce(asJson(s))), source);
+    if (isPageList(source))
+      return toPageList(
+        source.map(s => this.reduce(asJson(s))),
+        source
+      );
     if (isArray(source)) return source.map(s => this.reduce(asJson(s)));
     return this.reduce(asJson(source));
   }