@thisisagile/easy 15.29.2 → 16.0.0

package/src/types/Template.ts

@@ -1,8 +1,11 @@
 import { meta } from './Meta';
 import { List, toList } from './List';
-import { asString, text, Text, ToText } from './Text';
+import { asString, replaceAll, Text } from './Text';
 import { toName } from './Constructor';
-import { tryTo } from './Try';
+import { Optional } from './Types';
+import { Get, ofGet } from './Get';
+import { isEmpty, isNotEmpty } from './Is';
+import { JsonValue } from './Json';
 
 export type TemplateOptions = { type?: Text; property?: Text; actual?: Text; subject?: Text };
 
@@ -20,12 +23,6 @@ export class Template implements Text {
       .replace('  ', ' ');
   };
 
-  private readonly value = (subject: any, prop: string): string =>
-    tryTo(() => prop.split('.'))
-      .map(p => [p, p.splice(1)])
-      .map(([p, ps]) => ps.reduce((t: ToText, s) => (t as any)[s], text(subject[p[0]])))
-      .map(p => p.toString()).value;
-
   private readonly props = (tmpl: string, key: string, result: List<string> = toList()): string[] => {
     const i1 = tmpl.indexOf(`{${key}`);
     if (i1 < 0) {
@@ -36,17 +33,157 @@ export class Template implements Text {
   };
 
   private readonly object = (): string => {
-    return this.props(this.template, 'this').reduce((t: string, p) => t.replace(`{${p}}`, this.value(this.subject, p.replace('this.', ''))), this.template);
+    return this.props(this.template, 'this').reduce((t: string, p) => t.replace(`{${p}}`, textValue(this.subject, p.replace('this.', ''))), this.template);
   };
 
   private readonly option = (tmpl: string, prop: string): string => {
-    return this.props(tmpl, prop).reduce((t: string, p) => t.replace(`{${p}}`, this.value(this.options, p)), tmpl);
+    return this.props(tmpl, prop).reduce((t: string, p) => t.replace(`{${p}}`, textValue(this.options, p)), tmpl);
   };
 }
 
-export const template = (tmpl: Text, subject: unknown, options: TemplateOptions = {}): Text =>
-  new Template(asString(tmpl), subject, {
+export function template(tmpl: Text, subject: unknown, options: TemplateOptions = {}): Text {
+  return new Template(asString(tmpl), subject, {
     type: toName(subject),
     subject: text(JSON.stringify(subject)),
     ...options,
   });
+}
+
+export class ToText implements Text {
+  constructor(readonly subject: string) {}
+
+  get cap(): ToText {
+    return this.map(s => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase());
+  }
+
+  get title(): ToText {
+    return this.map(s =>
+      s
+        .split(' ')
+        .map(w => text(w).cap)
+        .join(' ')
+    );
+  }
+
+  get pascal(): ToText {
+    return this.title.replace(' ', '');
+  }
+
+  get lower(): ToText {
+    return this.map(s => s.toLowerCase());
+  }
+
+  get upper(): ToText {
+    return this.map(s => s.toUpperCase());
+  }
+
+  get camel(): ToText {
+    return this.title.trim.map(s => `${s.charAt(0).toLowerCase()}${s.slice(1)}`);
+  }
+
+  get kebab(): ToText {
+    return this.lower.replace(' ', '-');
+  }
+
+  get strictKebab(): ToText {
+    return this.map(s => s.replace(/[^a-z\d]+/gi, ' ').trim()).kebab;
+  }
+
+  get slug(): ToText {
+    return this.map(s =>
+      s
+        .replace(/ß/g, 'ss')
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036F]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z\d]+/g, '-')
+        .replace(/(^-)|(-$)/g, '')
+    );
+  }
+
+  get snake(): ToText {
+    return this.upper.replace(' ', '_');
+  }
+
+  get plural(): ToText {
+    return this.ifLike('') ?? this.add('s');
+  }
+
+  get space(): ToText {
+    return this.map(s => s.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/[_-]/g, ' '));
+  }
+
+  get sentence(): ToText {
+    return this.isEmpty ? this : this.map(s => `${s.charAt(0).toUpperCase()}${s.slice(1)}.`);
+  }
+
+  get initials(): ToText {
+    return this.map(s =>
+      s
+        .split(' ')
+        .map(w => w[0])
+        .join('')
+    );
+  }
+
+  get trim(): ToText {
+    return this.map(s => s.replace(/[- ,_#]/g, ''));
+  }
+
+  get isEmpty(): boolean {
+    return isEmpty(this.toString());
+  }
+
+  parse = (subject: unknown, options = {}): ToText => text(template(this.subject, subject, { type: toName(subject), ...options }));
+
+  is = (...others: unknown[]): boolean => others.some(o => this.toString() === text(o).toString());
+
+  equals = this.is;
+
+  isLike = (...others: unknown[]): boolean => others.some(o => this.trim.lower.is(text(o).trim.lower));
+
+  ifLike = (...others: unknown[]): Optional<this> => (this.isLike(...others) ? this : undefined);
+
+  endsWith = (end?: unknown): boolean => this.subject.endsWith(asString(end));
+
+  startsWith = (end?: unknown): boolean => this.subject.startsWith(asString(end));
+
+  first = (n: number): ToText => this.map(s => s.substring(0, n));
+
+  last = (n: number): ToText => this.map(s => s.substring(s.length - n));
+
+  map = (func: Get<string, string>): ToText => text(ofGet(func, this.subject));
+
+  replace = (search: Text, replace: Text): ToText => this.map(s => replaceAll(s, search, replace));
+
+  add = (add?: unknown, separator = ''): ToText => this.map(s => (isNotEmpty(add) ? `${s}${separator}${text(add)}` : s));
+
+  with = (separator: string, ...other: unknown[]): ToText =>
+    this.map(s =>
+      toList(s)
+        .add(...other.map(u => text(u).toString()))
+        .filter(s => isNotEmpty(s))
+        .join(separator)
+    );
+
+  toString(): string {
+    return this.subject;
+  }
+
+  toJSON(): JsonValue {
+    return this.subject;
+  }
+}
+
+export function text(subject?: unknown, alt = ''): ToText {
+  const sub = subject ? asString(subject) : alt;
+  return new ToText(sub !== '[object Object]' ? sub : '');
+}
+
+export function textValue(subject: any, prop: string): string {
+  const p = prop.split('.');
+  return p
+    .splice(1)
+    .reduce((t: ToText, s) => (t as any)[s], text(subject?.[p[0]]))
+    .toString();
+}

package/src/types/Text.ts

@@ -1,11 +1,6 @@
-import { isDefined, isEmpty, isNotEmpty } from './Is';
-import { toName } from './Constructor';
-import { template } from './Template';
+import { isDefined } from './Is';
 import { isFunc } from './Func';
 import { Get, ofGet } from './Get';
-import { toList } from './List';
-import { JsonValue } from './Json';
-import { Optional } from './Types';
 
 export type Text = { toString(): string };
 
@@ -19,138 +14,8 @@ export const toWords = (input: unknown): string[] => {
   return asString(input)
     .replace(/(\p{Lower})(\p{Upper})/gu, '$1 $2')
     .replace(/(\p{Upper})(\p{Upper}\p{Lower})/gu, '$1 $2')
-    .split(/[_\W]+/g).filter(Boolean);
+    .split(/[_\W]+/g)
+    .filter(Boolean);
 };
 
 export const kebab = (s = ''): string => toWords(s).join('-').toLowerCase();
-
-export class ToText implements Text {
-  constructor(readonly subject: string) {}
-
-  get cap(): ToText {
-    return this.map(s => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase());
-  }
-
-  get title(): ToText {
-    return this.map(s =>
-      s
-        .split(' ')
-        .map(w => text(w).cap)
-        .join(' ')
-    );
-  }
-
-  get pascal(): ToText {
-    return this.title.replace(' ', '');
-  }
-
-  get lower(): ToText {
-    return this.map(s => s.toLowerCase());
-  }
-
-  get upper(): ToText {
-    return this.map(s => s.toUpperCase());
-  }
-
-  get camel(): ToText {
-    return this.title.trim.map(s => `${s.charAt(0).toLowerCase()}${s.slice(1)}`);
-  }
-
-  get kebab(): ToText {
-    return this.lower.replace(' ', '-');
-  }
-
-  get strictKebab(): ToText {
-    return this.map(s => s.replace(/[^a-z\d]+/gi, ' ').trim()).kebab;
-  }
-
-  get slug(): ToText {
-    return this.map(s =>
-      s
-        .replace(/ß/g, 'ss')
-        .normalize('NFKD')
-        .replace(/[\u0300-\u036F]/g, '')
-        .toLowerCase()
-        .replace(/[^a-z\d]+/g, '-')
-        .replace(/(^-)|(-$)/g, '')
-    );
-  }
-
-  get snake(): ToText {
-    return this.upper.replace(' ', '_');
-  }
-
-  get plural(): ToText {
-    return this.ifLike('') ?? this.add('s');
-  }
-
-  get space(): ToText {
-    return this.map(s => s.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/[_-]/g, ' '));
-  }
-
-  get sentence(): ToText {
-    return this.isEmpty ? this : this.map(s => `${s.charAt(0).toUpperCase()}${s.slice(1)}.`);
-  }
-
-  get initials(): ToText {
-    return this.map(s =>
-      s
-        .split(' ')
-        .map(w => w[0])
-        .join('')
-    );
-  }
-
-  get trim(): ToText {
-    return this.map(s => s.replace(/[- ,_#]/g, ''));
-  }
-
-  get isEmpty(): boolean {
-    return isEmpty(this.toString());
-  }
-
-  parse = (subject: unknown, options = {}): ToText => text(template(this.subject, subject, { type: toName(subject), ...options }));
-
-  is = (...others: unknown[]): boolean => others.some(o => this.toString() === text(o).toString());
-
-  equals = this.is;
-
-  isLike = (...others: unknown[]): boolean => others.some(o => this.trim.lower.is(text(o).trim.lower));
-
-  ifLike = (...others: unknown[]): Optional<this> => (this.isLike(...others) ? this : undefined);
-
-  endsWith = (end?: unknown): boolean => this.subject.endsWith(asString(end));
-
-  startsWith = (end?: unknown): boolean => this.subject.startsWith(asString(end));
-
-  first = (n: number): ToText => this.map(s => s.substring(0, n));
-
-  last = (n: number): ToText => this.map(s => s.substring(s.length - n));
-
-  map = (func: Get<string, string>): ToText => text(ofGet(func, this.subject));
-
-  replace = (search: Text, replace: Text): ToText => this.map(s => replaceAll(s, search, replace));
-
-  add = (add?: unknown, separator = ''): ToText => this.map(s => (isNotEmpty(add) ? `${s}${separator}${text(add)}` : s));
-
-  with = (separator: string, ...other: unknown[]): ToText =>
-    this.map(s =>
-      toList(s)
-        .add(...other.map(u => text(u).toString()))
-        .filter(s => isNotEmpty(s))
-        .join(separator)
-    );
-
-  toString(): string {
-    return this.subject;
-  }
-
-  toJSON(): JsonValue {
-    return this.subject;
-  }
-}
-
-export const text = (subject?: unknown, alt = ''): ToText => {
-  const sub = subject ? asString(subject) : alt;
-  return new ToText(sub !== '[object Object]' ? sub : '');
-};

package/src/types/Try.ts

@@ -1,5 +1,5 @@
 import { isDefined, isEmpty, isTrue } from './Is';
-import { validate } from '../validation';
+import { validate } from '../validation/Validate';
 import { Construct, Constructor, ofConstruct } from './Constructor';
 import { Validatable } from './Validatable';
 import { Get, ofGet } from './Get';

package/src/types/Uri.ts

@@ -3,10 +3,11 @@ import { asString, Text } from './Text';
 import { toName } from './Constructor';
 import { ctx } from './Context';
 import { List, toList } from './List';
-import { entries, meta } from './Meta';
+import { meta } from './Meta';
 import { tryTo } from './Try';
 import { Optional } from './Types';
 import { OneOrMore, toArray } from './Array';
+import { entries } from './Object';
 
 export type Segment = Text & { key?: string; segment?: string; query?: (value: unknown) => string };
 

package/src/types/Value.ts

@@ -1,4 +1,7 @@
-import { asString, isDefined, JsonValue, Validatable } from './index';
+import { Validatable } from './Validatable';
+import { isDefined } from './Is';
+import { JsonValue } from './Json';
+import { asString } from './Text';
 
 export class Value<V = string> implements Validatable {
   constructor(readonly value: V) {

package/src/utils/Base64.ts

@@ -1,4 +1,4 @@
-import { Json } from '../types';
+import type { Json } from '../types/Json';
 
 export const base64 = {
   decode: (data: string): string => Buffer.from(data, 'base64').toString('utf-8'),

package/src/utils/Convert.ts

@@ -1,7 +1,10 @@
-import { asString } from '../types';
+import { asString } from '../types/Text';
 
 export class Convert<From = unknown, To = unknown> {
-  constructor(public readonly from: (f: From) => To, public readonly to: (t: To) => From) {}
+  constructor(
+    public readonly from: (f: From) => To,
+    public readonly to: (t: To) => From
+  ) {}
 }
 
 export const convert = {

package/src/utils/If.ts

@@ -1,4 +1,6 @@
-import { Construct, isDefined, isNotEmpty, isTrue, ofConstruct, Optional } from '../types';
+import { isDefined, isNotEmpty, isTrue } from '../types/Is';
+import { Optional } from '../types/Types';
+import { Construct, ofConstruct } from '../types/Constructor';
 
 export function ifTrue<Out, In = unknown>(o: unknown, f: Construct<Out, NonNullable<In>>, alt: Construct<Out>): Out;
 export function ifTrue<Out, In = unknown>(o: unknown, f: Construct<Out, NonNullable<In>>, alt?: Construct<Out>): Optional<Out>;

package/src/utils/Loading.ts

@@ -1,3 +1,3 @@
-import { isNotPresent } from '../types';
+import { isNotPresent } from '../types/Is';
 
 export const isLoading = (...targets: unknown[]): boolean => isNotPresent(...targets);

package/src/utils/Log.ts

@@ -1,4 +1,4 @@
-import { Optional } from '../types';
+import { Optional } from '../types/Types';
 
 export function log<T>(t: T): T;
 export function log<T>(label: string, t: T): T;

package/src/utils/Mapper.ts

@@ -1,7 +1,15 @@
-import { Construct, Get, isA, isEmpty, json, Json, JsonValue, List, meta, ofConstruct, ofGet, Optional, toList, TypeGuard } from '../types';
 import { Property, PropertyOptions } from './Property';
 import { State } from './State';
 import { ifNotEmpty } from './If';
+import { json, Json, JsonValue } from '../types/Json';
+import { Optional } from '../types/Types';
+import { TypeGuard } from '../types/TypeGuard';
+import { isA } from '../types/IsA';
+import { List, toList } from '../types/List';
+import { meta } from '../types/Meta';
+import { isEmpty } from '../types/Is';
+import { Get, ofGet } from '../types/Get';
+import { Construct, ofConstruct } from '../types/Constructor';
 
 export type Mapping = {
   property: string;
@@ -16,7 +24,10 @@ export type MapOptions = { startFrom: MapStartFrom };
 export class Mapper extends State implements Mapping {
   protected readonly map = mappings;
 
-  constructor(readonly options: MapOptions = { startFrom: 'scratch' }, readonly property = '') {
+  constructor(
+    readonly options: MapOptions = { startFrom: 'scratch' },
+    readonly property = ''
+  ) {
     super();
   }
 

package/src/utils/Promise.ts

@@ -1,4 +1,6 @@
-import { ErrorOrigin, List, toArray, toList } from '../types';
+import { toArray } from '../types/Array';
+import { ErrorOrigin } from '../types/ErrorOrigin';
+import { List, toList } from '../types/List';
 
 type Pro<A> = A | PromiseLike<A>;
 type Aw<A> = Awaited<A>;

package/src/utils/Property.ts

@@ -1,6 +1,7 @@
 import { convert, Convert } from './Convert';
-import { Get, Json, JsonValue, ofGet } from '../types';
 import { Mapping } from './Mapper';
+import { Get, ofGet } from '../types/Get';
+import { Json, JsonValue } from '../types/Json';
 
 export type PropertyOptions<T = unknown> = {
   convert?: Convert<any, any>;
@@ -9,7 +10,10 @@ export type PropertyOptions<T = unknown> = {
 };
 
 export class Property<T = unknown> implements Mapping {
-  constructor(readonly property: string, readonly options?: PropertyOptions) {
+  constructor(
+    readonly property: string,
+    readonly options?: PropertyOptions
+  ) {
     this.options = { ...options, convert: options?.convert ?? convert.default };
   }
 

package/src/utils/Sentence.ts

@@ -1,7 +1,13 @@
-import { Id, text, Text } from '../types';
+import type { Text } from '../types/Text';
+import { text } from '../types/Template';
+import { Id } from '../types/Id';
 
 export class Sentence implements Text {
-  constructor(word: Text, pre?: Sentence, private sentence: Text[] = (pre?.sentence ?? []).concat(word)) {}
+  constructor(
+    word: Text,
+    pre?: Sentence,
+    private sentence: Text[] = (pre?.sentence ?? []).concat(word)
+  ) {}
 
   toString(): string {
     return text(this.sentence.join(' ')).sentence.toString();

package/src/utils/State.ts

@@ -1,4 +1,4 @@
-import { Construct, ofConstruct } from '../types';
+import { Construct, ofConstruct } from '../types/Constructor';
 
 export class State {
   constructor(protected readonly state: any = {}) {}

package/src/utils/View.ts

@@ -1,26 +1,15 @@
-import {
-  asJson,
-  choose,
-  Constructor,
-  DontInfer,
-  isArray,
-  isBoolean,
-  isConstructor,
-  isEqual,
-  isFunction,
-  isPageList,
-  isString,
-  json,
-  Json,
-  List,
-  meta,
-  PageList,
-  Primitive,
-  toPageList,
-  use,
-} from '../types';
 import { traverse } from './Traverse';
 import { ifDefined } from './If';
+import { Primitive } from '../types/Primitive';
+import { Constructor, isConstructor, use } from '../types/Constructor';
+import { asJson, json, Json } from '../types/Json';
+import { choose } from '../types/Case';
+import { isArray, isBoolean, isFunction, isString } from '../types/Is';
+import { meta } from '../types/Meta';
+import { isPageList, PageList, toPageList } from '../types/PageList';
+import { List } from '../types/List';
+import { isEqual } from '../types/IsEqual';
+import { DontInfer } from '../types/Types';
 
 type Func<T = unknown> = (a: any, key?: string) => T;
 type Viewer = { key: string; f: Func };
@@ -59,7 +48,11 @@ const toViewers = (views: ViewRecord): Viewer[] =>
     .map(([k, v]) => toViewer(k, v));
 
 export class View<V = Json> {
-  constructor(private views = {} as ViewRecord<V>, readonly startsFrom: 'scratch' | 'source' = 'scratch', readonly viewers: Viewer[] = toViewers(views)) {}
+  constructor(
+    private views = {} as ViewRecord<V>,
+    readonly startsFrom: 'scratch' | 'source' = 'scratch',
+    readonly viewers: Viewer[] = toViewers(views)
+  ) {}
 
   get fromSource(): View<V> {
     return new View(this.views, 'source', this.viewers);

package/src/validation/Contraints.ts

@@ -1,5 +1,13 @@
-import { Func, inFuture, inPast, isBoolean, isDefined, isFunction, isIn, isNotEmpty, isString, List, meta, Results, text, Text, toList, tryTo } from '../types';
 import { validate, Validator } from './Validate';
+import { Func } from '../types/Func';
+import { Results } from '../types/Results';
+import { meta } from '../types/Meta';
+import { List, toList } from '../types/List';
+import { isBoolean, isDefined, isFunction, isIn, isNotEmpty, isString } from '../types/Is';
+import { tryTo } from '../types/Try';
+import { text } from '../types/Template';
+import { inFuture, inPast } from '../types/IsDate';
+import type { Text } from '../types/Text';
 
 export type Constraint = Func<boolean | Results, any>;
 

package/src/validation/Validate.ts

@@ -1,26 +1,19 @@
-import {
-  asString,
-  choose,
-  isArray,
-  isEnum,
-  isFunction,
-  isResults,
-  isValidatable,
-  isValue,
-  List,
-  meta,
-  Results,
-  TemplateOptions,
-  text,
-  Text,
-  toList,
-  toName,
-  toResult,
-  toResults,
-  tryTo,
-} from '../types';
 import { Constraint } from './Contraints';
 import { when } from './When';
+import { text } from '../types/Template';
+import type { TemplateOptions } from '../types/Template';
+import { isResults, Results, toResults } from '../types/Results';
+import { toName } from '../types/Constructor';
+import { toResult } from '../types/Result';
+import { List, toList } from '../types/List';
+import { meta } from '../types/Meta';
+import { isArray, isFunction } from '../types/Is';
+import { asString } from '../types/Text';
+import { choose } from '../types/Case';
+import { isEnum } from '../types/Enum';
+import { isValue } from '../types/Value';
+import { isValidatable } from '../types/Validatable';
+import type { Text } from '../types/Text';
 
 export type Validator = { property: string | symbol; constraint: Constraint; text: Text; actual?: Text };
 
@@ -32,16 +25,20 @@ const validators = (subject: unknown): List<Validator> =>
     .keys<List<Validator>>('constraint')
     .reduce((list, vs) => list.add(vs), toList<Validator>());
 
-const runValidator = (v: Validator, subject?: unknown): Results =>
-  tryTo(() => (isFunction((subject as any)[v.property]) ? (subject as any)[v.property]() : (subject as any)[v.property]))
-    .map(actual => [actual, v.constraint(actual)])
-    .map(([actual, res]) => (isResults(res) ? res : !res ? asResults(subject, v.text, { ...v, actual }) : toResults()))
-    .recover(e => asResults(subject, asString(e))).value;
+const runValidator = (v: Validator, subject?: unknown): Results => {
+  try {
+    const actual = isFunction((subject as any)[v.property]) ? (subject as any)[v.property]() : (subject as any)[v.property];
+    const constraint = v.constraint(actual);
+    return isResults(constraint) ? constraint : !constraint ? asResults(subject, v.text, { ...v, actual }) : toResults();
+  } catch (e) {
+    return asResults(subject, asString(e));
+  }
+};
 
 const constraints = (subject?: unknown): Results =>
-  tryTo(() => validators(subject))
-    .map(vs => vs.mapDefined(v => runValidator(v, subject)))
-    .map(res => res.reduce((rs, r) => rs.add(...r.results), toResults())).value;
+  validators(subject)
+    .map(vs => runValidator(vs, subject))
+    .reduce((rs, r) => rs.add(...r.results), toResults());
 
 export const validate = (subject?: unknown): Results =>
   choose(subject)

package/src/validation/When.ts

@@ -1,9 +1,19 @@
-import { Constructor, ErrorOrigin, Exception, Get, isDefined, isEmpty, isIn, ofGet, Predicate, Results, toArray } from '../types';
 import { validate } from './Validate';
-import { reject, resolve } from '../utils';
+import { Results } from '../types/Results';
+import { Constructor } from '../types/Constructor';
+import { Get, ofGet, Predicate } from '../types/Get';
+import { isDefined, isEmpty, isIn } from '../types/Is';
+import { toArray } from '../types/Array';
+import { ErrorOrigin } from '../types/ErrorOrigin';
+import { reject, resolve } from '../utils/Promise';
+import { Exception } from '../types/Exception';
 
 export class When<W> {
-  constructor(readonly subject: W, readonly valid = true, private results?: Results) {}
+  constructor(
+    readonly subject: W,
+    readonly valid = true,
+    private results?: Results
+  ) {}
 
   get not(): When<W> {
     return this.clone(!this.valid);

package/dist/chunk-2L3GZ6NK.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/sql/Count.ts"],"sourcesContent":["import { ifGet } from '../types';\nimport { Select } from './Select';\n\nexport class Count extends Select {\n  toString(): string {\n    return (\n      `SELECT COUNT(*)` +\n      ifGet(this._top, ` TOP ${this._top}`, '') +\n      ` FROM ${this.table}` +\n      ifGet(this.clauses.length, ` WHERE ${this.clauses.join(' AND ')}`, '') +\n      ifGet(this.grouped.length, ` GROUP BY ${this.grouped.join(', ')}`, '') +\n      ';'\n    );\n  }\n}\n"],"mappings":";;;;;;;;AAGO,IAAM,QAAN,cAAoB,OAAO;AAAA,EAChC,WAAmB;AACjB,WACE,oBACA,MAAM,KAAK,MAAM,QAAQ,KAAK,IAAI,IAAI,EAAE,IACxC,SAAS,KAAK,KAAK,KACnB,MAAM,KAAK,QAAQ,QAAQ,UAAU,KAAK,QAAQ,KAAK,OAAO,CAAC,IAAI,EAAE,IACrE,MAAM,KAAK,QAAQ,QAAQ,aAAa,KAAK,QAAQ,KAAK,IAAI,CAAC,IAAI,EAAE,IACrE;AAAA,EAEJ;AACF;","names":[]}

package/dist/chunk-3MOFYE2N.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/services/ApiGateway.ts"],"sourcesContent":["import { Api, RouteOptions } from './Api';\nimport { FetchOptions, Gateway, Json, Optional, PageList, toPageList, Uri, use } from '../types';\nimport { RequestOptions } from '../http';\n\nexport class ApiGateway extends Gateway<RouteOptions> {\n  constructor(readonly api: Api = new Api()) {\n    super();\n  }\n\n  get(uri: Uri, options?: RouteOptions): Promise<PageList<Json>> {\n    return this.api.get(uri, options).then(r => use(r.body.data, d => toPageList(d?.items, { total: d?.totalItems, ...d?.meta })));\n  }\n\n  getOne(uri: Uri, options?: RouteOptions): Promise<Optional<Json>> {\n    return this.get(uri, options).then(r => r.first());\n  }\n\n  post(uri: Uri, item?: Json, options?: RouteOptions): Promise<Json> {\n    return this.api.post(uri, item, options).then(r => r.body.data?.items.first() ?? {});\n  }\n\n  postSearch(uri: Uri, options?: RequestOptions | FetchOptions): Promise<PageList<Json>> {\n    return this.api.post(uri, options).then(r => use(r.body.data, d => toPageList(d?.items, { total: d?.totalItems, ...d?.meta })));\n  }\n\n  patch(uri: Uri, item?: Json, options?: RouteOptions): Promise<Json> {\n    return this.api.patch(uri, item, options).then(r => r.body.data?.items.first() ?? {});\n  }\n\n  put(uri: Uri, item?: Json, options?: RouteOptions): Promise<Json> {\n    return this.api.put(uri, item, options).then(r => r.body.data?.items.first() ?? {});\n  }\n\n  delete(uri: Uri, options?: RouteOptions): Promise<boolean> {\n    return this.api.delete(uri, options).then(() => true);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAIO,IAAM,aAAN,cAAyB,QAAsB;AAAA,EACpD,YAAqB,MAAW,IAAI,IAAI,GAAG;AACzC,UAAM;AADa;AAAA,EAErB;AAAA,EAEA,IAAI,KAAU,SAAiD;AAC7D,WAAO,KAAK,IAAI,IAAI,KAAK,OAAO,EAAE,KAAK,OAAK,IAAI,EAAE,KAAK,MAAM,OAAK,WAAW,GAAG,OAAO,EAAE,OAAO,GAAG,YAAY,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC;AAAA,EAC/H;AAAA,EAEA,OAAO,KAAU,SAAiD;AAChE,WAAO,KAAK,IAAI,KAAK,OAAO,EAAE,KAAK,OAAK,EAAE,MAAM,CAAC;AAAA,EACnD;AAAA,EAEA,KAAK,KAAU,MAAa,SAAuC;AACjE,WAAO,KAAK,IAAI,KAAK,KAAK,MAAM,OAAO,EAAE,KAAK,OAAK,EAAE,KAAK,MAAM,MAAM,MAAM,KAAK,CAAC,CAAC;AAAA,EACrF;AAAA,EAEA,WAAW,KAAU,SAAkE;AACrF,WAAO,KAAK,IAAI,KAAK,KAAK,OAAO,EAAE,KAAK,OAAK,IAAI,EAAE,KAAK,MAAM,OAAK,WAAW,GAAG,OAAO,EAAE,OAAO,GAAG,YAAY,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC;AAAA,EAChI;AAAA,EAEA,MAAM,KAAU,MAAa,SAAuC;AAClE,WAAO,KAAK,IAAI,MAAM,KAAK,MAAM,OAAO,EAAE,KAAK,OAAK,EAAE,KAAK,MAAM,MAAM,MAAM,KAAK,CAAC,CAAC;AAAA,EACtF;AAAA,EAEA,IAAI,KAAU,MAAa,SAAuC;AAChE,WAAO,KAAK,IAAI,IAAI,KAAK,MAAM,OAAO,EAAE,KAAK,OAAK,EAAE,KAAK,MAAM,MAAM,MAAM,KAAK,CAAC,CAAC;AAAA,EACpF;AAAA,EAEA,OAAO,KAAU,SAA0C;AACzD,WAAO,KAAK,IAAI,OAAO,KAAK,OAAO,EAAE,KAAK,MAAM,IAAI;AAAA,EACtD;AACF;","names":[]}