@thisisagile/easy 14.2.2 → 14.2.3

package/src/types/Uri.ts

@@ -1,115 +1,120 @@
-import {isBoolean, isDefined, isNotEmpty, isTrue} from './Is';
-import {asString, Text} from './Text';
-import {toName} from './Constructor';
-import {ctx} from './Context';
-import {List, toList} from './List';
-import {meta} from './Meta';
-import {tryTo} from './Try';
-import {Optional} from './Types';
-import {OneOrMore, toArray} from "./Array";
+import { isBoolean, isDefined, isNotEmpty, isTrue } from './Is';
+import { asString, Text } from './Text';
+import { toName } from './Constructor';
+import { ctx } from './Context';
+import { List, toList } from './List';
+import { meta } from './Meta';
+import { tryTo } from './Try';
+import { Optional } from './Types';
+import { OneOrMore, toArray } from './Array';
 
 export type Segment = Text & { key?: string; segment?: string; query?: (value: unknown) => string };
 
-export const toSegment = (key?: Text, {segment, query}: {
-    segment?: string;
-    query?: (value: unknown) => string
-} = {}): Segment => ({
-    key: key as string,
+export const toSegment = (
+  key?: Text,
+  {
     segment,
     query,
-    toString: () => asString(key),
+  }: {
+    segment?: string;
+    query?: (value: unknown) => string;
+  } = {}
+): Segment => ({
+  key: key as string,
+  segment,
+  query,
+  toString: () => asString(key),
 });
 
 export const uri = {
-    host: (key?: string): Segment => toSegment(key, {segment: key ?? ctx.env.host ?? '$host'}),
-    resource: (resource: Uri): Segment => toSegment(toName(resource, 'Uri'), {segment: toName(resource, 'Uri')}),
-    segment: (key?: Text): Segment => toSegment(key, {segment: key as string}),
-    path: (key: Text): Segment => toSegment(key, {segment: `:${key}`}),
-    query: (key: Text): Segment => toSegment(key, {query: (value: unknown): string => (isDefined(value) ? `${key}=${value}` : '')}),
-    boolean: (key: Text): Segment => toSegment(key, {query: (value: unknown): string => (isTrue(value) ? `${key}` : '')}),
+  host: (key?: string): Segment => toSegment(key, { segment: key ?? ctx.env.host ?? '$host' }),
+  resource: (resource: Uri): Segment => toSegment(toName(resource, 'Uri'), { segment: toName(resource, 'Uri') }),
+  segment: (key?: Text): Segment => toSegment(key, { segment: key as string }),
+  path: (key: Text): Segment => toSegment(key, { segment: `:${key}` }),
+  query: (key: Text): Segment => toSegment(key, { query: (value: unknown): string => (isDefined(value) ? `${key}=${value}` : '') }),
+  boolean: (key: Text): Segment => toSegment(key, { query: (value: unknown): string => (isTrue(value) ? `${key}` : '') }),
 };
 
 type Prop = { segment: Segment; value: any };
 
 const toRoute = (...segments: Segment[]): string =>
-    toList(segments)
-        .mapDefined(s => s.segment)
-        .join('/');
+  toList(segments)
+    .mapDefined(s => s.segment)
+    .join('/');
 
 export type Uri = {
-    id: (id?: unknown) => Uri;
-    query: (q?: unknown) => Uri;
-    skip: (n?: number) => Uri;
-    take: (n?: number) => Uri;
-    path: string;
-    route: (resource: string) => string;
-    isInternal: boolean;
-    toString: () => string;
+  id: (id?: unknown) => Uri;
+  query: (q?: unknown) => Uri;
+  skip: (n?: number) => Uri;
+  take: (n?: number) => Uri;
+  path: string;
+  route: (resource: string) => string;
+  isInternal: boolean;
+  toString: () => string;
 };
 
 export type UriExpandProps = { q: string };
 
 export class EasyUri<Props = UriExpandProps> implements Uri {
-    static readonly id = uri.path('id');
-    static readonly ids = uri.query('ids');
-    static readonly query = uri.query('q');
-    static readonly skip = uri.query('skip');
-    static readonly take = uri.query('take');
-
-    readonly host = uri.host();
-    readonly resource = uri.resource(this);
-
-    protected state: any = {};
-
-    constructor(readonly segments: Segment[] = []) {
-    }
-
-    get path(): string {
-        return toRoute(uri.segment(''), this.resource, ...this.segments);
-    }
-
-    get complete(): string {
-        return toRoute(this.host, this.resource, ...this.segments);
-    }
-
-    get isInternal(): boolean {
-        return toRoute(this.host) === (ctx.env.host ?? '$host');
-    }
-
-    protected get props(): List<Prop> {
-        return meta(this.state).values<Prop>();
-    }
-
-    route = (resource: Optional<string> = this.resource.key): string => toRoute(uri.segment(''), uri.segment(resource?.toLowerCase()), ...this.segments);
-
-    set = (segment: Segment, value?: unknown): this => {
-        tryTo(value)
-            .is.defined()
-            .accept(value => (this.state[segment.key ?? ''] = {segment, value}));
-        return this;
-    };
-
-    toString(): string {
-        return tryTo(() => this.props)
-            .map(ps => ps.filter(p => p.segment?.segment))
-            .map(ps => ps.reduce((r: string, p: Prop) => r.replace(asString(p.segment.segment), asString(p.value)), this.complete))
-            .map(route => ({
-                route,
-                query: this.props.mapDefined(p => (p.segment?.query ? p.segment?.query(p.value) : undefined))?.join('&')
-            }))
-            .map(({route, query}) => (isNotEmpty(query) ? `${route}?${query}` : route)).value;
-    }
-
-    id = (id?: unknown): this => this.set(EasyUri.id, id);
-    ids = (ids: OneOrMore<unknown>): this => this.set(EasyUri.ids, toArray(ids).join(','));
-    query = (q?: unknown): this => this.set(EasyUri.query, q);
-
-    skip = (index?: number): this => this.set(EasyUri.skip, index);
-    take = (items?: number): this => this.set(EasyUri.take, items);
-
-    expand(props: Partial<Props>): this {
-        return meta(props).entries().reduce((u, [k, v]) =>
-                isBoolean(v) ? u.set(uri.boolean(k), v) : u.set(uri.query(k), toArray(v).join(","))
-            , this)
-    }
+  static readonly id = uri.path('id');
+  static readonly ids = uri.query('ids');
+  static readonly query = uri.query('q');
+  static readonly skip = uri.query('skip');
+  static readonly take = uri.query('take');
+
+  readonly host = uri.host();
+  readonly resource = uri.resource(this);
+
+  protected state: any = {};
+
+  constructor(readonly segments: Segment[] = []) {}
+
+  get path(): string {
+    return toRoute(uri.segment(''), this.resource, ...this.segments);
+  }
+
+  get complete(): string {
+    return toRoute(this.host, this.resource, ...this.segments);
+  }
+
+  get isInternal(): boolean {
+    return toRoute(this.host) === (ctx.env.host ?? '$host');
+  }
+
+  protected get props(): List<Prop> {
+    return meta(this.state).values<Prop>();
+  }
+
+  route = (resource: Optional<string> = this.resource.key): string => toRoute(uri.segment(''), uri.segment(resource?.toLowerCase()), ...this.segments);
+
+  set = (segment: Segment, value?: unknown): this => {
+    tryTo(value)
+      .is.defined()
+      .accept(value => (this.state[segment.key ?? ''] = { segment, value }));
+    return this;
+  };
+
+  toString(): string {
+    return tryTo(() => this.props)
+      .map(ps => ps.filter(p => p.segment?.segment))
+      .map(ps => ps.reduce((r: string, p: Prop) => r.replace(asString(p.segment.segment), asString(p.value)), this.complete))
+      .map(route => ({
+        route,
+        query: this.props.mapDefined(p => (p.segment?.query ? p.segment?.query(p.value) : undefined))?.join('&'),
+      }))
+      .map(({ route, query }) => (isNotEmpty(query) ? `${route}?${query}` : route)).value;
+  }
+
+  id = (id?: unknown): this => this.set(EasyUri.id, id);
+  ids = (ids: OneOrMore<unknown>): this => this.set(EasyUri.ids, toArray(ids).join(','));
+  query = (q?: unknown): this => this.set(EasyUri.query, q);
+
+  skip = (index?: number): this => this.set(EasyUri.skip, index);
+  take = (items?: number): this => this.set(EasyUri.take, items);
+
+  expand(props: Partial<Props>): this {
+    return meta(props)
+      .entries()
+      .reduce((u, [k, v]) => (isBoolean(v) ? u.set(uri.boolean(k), v) : u.set(uri.query(k), toArray(v).join(','))), this);
+  }
 }

package/src/utils/View.ts

@@ -29,13 +29,13 @@ export type InOut = { in?: Func | View<any>; col?: string };
 const isColOnly = (v: unknown): v is InOut => isObject(v) && isDefined(v.col) && !isDefined(v.in);
 const isInOnly = (v: unknown): v is InOut => isObject(v) && !isDefined(v.col) && isFunction(v.in);
 const isColAndFunction = (
-  v: unknown,
+  v: unknown
 ): v is {
   col: string;
   in: Func;
 } => isObject(v) && isDefined(v.col) && isFunction(v.in);
 const isColAndView = (
-  v: unknown,
+  v: unknown
 ): v is {
   col: string;
   in: View;
@@ -50,9 +50,9 @@ const toFunc = (a: any, col: string, f: Func = a => a): Func =>
 const toViewer = (key: string, value: unknown): Viewer =>
   choose(value)
     .is.not.defined(
-    v => v,
-    () => toViewer(key, () => undefined),
-  )
+      v => v,
+      () => toViewer(key, () => undefined)
+    )
     .type(isBoolean, b => toViewer(key, () => b))
     .type(isNumber, n => toViewer(key, () => n))
     .type(isString, s => toViewer(key, (a: any) => toFunc(a, s)(a)))
@@ -69,8 +69,7 @@ const toViewers = (views: Views): Viewer[] =>
     .map(([k, v]) => toViewer(k, v));
 
 export class View<V = Json> {
-  constructor(private views: Views<V> = {} as Views<V>, readonly startsFrom: 'scratch' | 'source' = 'scratch', readonly viewers: Viewer[] = toViewers(views)) {
-  }
+  constructor(private views: Views<V> = {} as Views<V>, readonly startsFrom: 'scratch' | 'source' = 'scratch', readonly viewers: Viewer[] = toViewers(views)) {}
 
   get fromSource(): View<V> {
     return new View(this.views, 'source', this.viewers);
@@ -84,7 +83,7 @@ export class View<V = Json> {
     if (isPageList(source))
       return toPageList(
         source.map(s => this.reduce(asJson(s))),
-        source,
+        source
       );
     if (isArray(source)) return source.map(s => this.reduce(asJson(s)));
     return this.reduce(asJson(source));
@@ -105,11 +104,11 @@ export const views = {
   keepOr: (alt?: unknown) => (a: unknown, key?: string) => traverse(a, key) ?? alt,
   or:
     (key: string, alt = '') =>
-      (a: unknown) =>
-        traverse(a, key) ?? alt,
+    (a: unknown) =>
+      traverse(a, key) ?? alt,
   value: (value: unknown) => () => value,
   to:
     <T>(ctor: Constructor<T>) =>
-      (a: unknown, key?: string) =>
-        new ctor(traverse(a, key)),
+    (a: unknown, key?: string) =>
+      new ctor(traverse(a, key)),
 };