@thisisagile/easy 18.5.0 → 18.7.0

package/dist/{chunk-UL2QXFW5.mjs → chunk-TUO7ZPSP.mjs}

@@ -1,43 +1,34 @@
-import {
-  reject,
-  resolve
-} from "./chunk-HNW64DUZ.mjs";
 import {
   isValidatable
 } from "./chunk-GPNPXSOF.mjs";
-import {
-  isValue
-} from "./chunk-AMS2ELWR.mjs";
-import {
-  Enum,
-  isEnum
-} from "./chunk-VN4JL4JB.mjs";
-import {
-  meta
-} from "./chunk-FECVT2OY.mjs";
-import {
-  entries
-} from "./chunk-GRMWYEPU.mjs";
-import {
-  toList
-} from "./chunk-MQ6KZAFL.mjs";
 import {
   toArray
 } from "./chunk-QCPWEAAJ.mjs";
+import {
+  traverse
+} from "./chunk-SSROJBD5.mjs";
+import {
+  isValue
+} from "./chunk-AMS2ELWR.mjs";
 import {
   asString,
   capitalize,
+  equals,
   replaceAll
 } from "./chunk-4Q6IHSAU.mjs";
 import {
-  ofGet
+  ofGet,
+  ofProperty
 } from "./chunk-SJGQU3OG.mjs";
 import {
-  isA
+  isA,
+  isAn
 } from "./chunk-MDIO6K2O.mjs";
 import {
   ofConstruct,
-  toName
+  on,
+  toName,
+  use
 } from "./chunk-QK5XGRSM.mjs";
 import {
   isArray,
@@ -46,9 +37,144 @@ import {
   isFunction,
   isIn,
   isNotEmpty,
+  isObject,
+  isPresent,
   isTrue
 } from "./chunk-YYWOQNZQ.mjs";
 
+// src/types/Object.ts
+function entries(subject) {
+  return ifDefined(
+    subject,
+    () => toList([...Object.entries(subject), ...Object.entries(Object.getPrototypeOf(subject) ?? {})]),
+    () => toList()
+  );
+}
+function values(subject) {
+  return toList([...Object.values(subject), ...Object.values(Object.getPrototypeOf(subject) ?? {})]);
+}
+function keys(subject) {
+  return toList([...Object.keys(subject), ...Object.keys(Object.getPrototypeOf(subject) ?? {})]);
+}
+function extractKeys(obj, keys2) {
+  return keys2.filter((k) => k in obj).reduce(
+    (acc, key) => {
+      acc.keys[key] = obj[key];
+      delete acc[key];
+      return acc;
+    },
+    { keys: {}, ...obj }
+  );
+}
+
+// src/utils/Promise.ts
+var resolve = (subject) => Promise.resolve(subject);
+var reject = (e) => Promise.reject(e);
+var tuple = {
+  2: (first, second) => Promise.all([first, second]),
+  3: (first, second, third) => Promise.all([first, second, third]),
+  4: (first, second, third, forth) => Promise.all([first, second, third, forth]),
+  5: (first, second, third, forth, fifth) => Promise.all([first, second, third, forth, fifth]),
+  all: (first, second) => Promise.all([first, Promise.all(second)]),
+  spread: (first, ...second) => Promise.all([first, Promise.all(toArray(second))]),
+  list: (list) => Promise.all([...list]).then(toList),
+  settled: (list) => Promise.allSettled([...list]).then((rs) => ({
+    fulfilled: toList(...rs.filter((r) => r.status === "fulfilled").map((r) => r.value)),
+    rejected: toList(...rs.filter((r) => r.status === "rejected").map((r) => asString(r.reason)))
+  })),
+  object: (obj) => use(keys(obj), (ks) => tuple.list(values(obj)).then((vs) => vs.reduce((acc, v, i) => on(acc, (a) => a[ks[i]] = v), {})))
+};
+var tuple2 = tuple[2];
+var tuple3 = tuple[3];
+var tuple4 = tuple[4];
+var tuple5 = tuple[5];
+var tupleO = tuple.object;
+var settled = tuple.settled;
+
+// src/types/Meta.ts
+import "reflect-metadata";
+var ClassMeta = class {
+  constructor(subject, data = (subject.prototype ?? subject).constructor) {
+    this.subject = subject;
+    this.data = data;
+  }
+  get = (key) => Reflect.getMetadata(key, this.data);
+  set = (key, value) => {
+    Reflect.defineMetadata(key, value, this.data);
+    return value;
+  };
+  entries = () => entries(this.subject);
+  parse = (f, options = {}) => {
+    const { initial = {}, skipUndefined = false } = options;
+    return this.entries().reduce((a, [k, val]) => use(f(val), (v) => isDefined(v) || !skipUndefined ? on(a, (a2) => a2[k] = v) : a), initial);
+  };
+  properties = (key) => toList([...Object.getOwnPropertyNames(this.subject), ...Object.getOwnPropertyNames(Object.getPrototypeOf(this.subject))]).map((p) => this.property(p)).filter((p) => key ? p.get(key) : p);
+  keys = (key) => this.properties().map((p) => p.get(key)).reduce((list, u) => u ? list.add(u) : list, toList());
+  values = () => values(this.subject);
+  property = (property) => new PropertyMeta(this.subject, property);
+};
+var PropertyMeta = class {
+  constructor(subject, property, data = Reflect.getMetadata(property, subject)) {
+    this.subject = subject;
+    this.property = property;
+    this.data = data;
+  }
+  get value() {
+    return this.subject[this.property];
+  }
+  get = (key) => isDefined(this.data) && isDefined(this.data[key]) ? this.data[key] : void 0;
+  set = (key, value) => {
+    Reflect.defineMetadata(this.property, { ...this.data, [key]: value }, this.subject);
+    return value;
+  };
+};
+var meta = (subject) => new ClassMeta(subject ?? {});
+
+// src/types/Enum.ts
+var isEnumConstructor = (c) => isFunction(c) && c.isEnum;
+var Enum = class {
+  constructor(name, id = name.toLowerCase(), code = id.toString()) {
+    this.name = name;
+    this.id = id;
+    this.code = code;
+  }
+  static isEnum = true;
+  get isValid() {
+    return isDefined(this.id);
+  }
+  static all() {
+    return meta(this.allTuple()).values();
+  }
+  static filter(p, params) {
+    return this.all().filter(p, params);
+  }
+  static first(p, params) {
+    return this.all().first(p, params);
+  }
+  static byIds(ids = []) {
+    return toList(ids).mapDefined((id) => this.byId(id)).distinct();
+  }
+  static byId(id, alt) {
+    return this.allTuple()[id] ?? ofGet(alt);
+  }
+  static allTuple() {
+    return meta(this).get(`all-${this.name}`) ?? meta(this).set(`all-${this.name}`, meta(this).values().filter(isEnum).toObject("id"));
+  }
+  equals(other) {
+    return this.id === (isEnum(other) ? other.id : other);
+  }
+  isIn(...items) {
+    return items.some((i) => this.equals(i));
+  }
+  toJSON() {
+    return this.id;
+  }
+  toString() {
+    return this.id.toString();
+  }
+};
+var isEnum = (e) => isDefined(e) && e instanceof Enum && isAn(e, "name", "id", "code");
+
 // src/types/Try.ts
 var Try = class _Try {
   is = {
@@ -288,6 +414,64 @@ function textValue(subject, prop) {
   return p.splice(1).reduce((t, s) => (typeof t === "object" && t !== null ? t : text(t))?.[s], initial)?.toString() ?? "";
 }
 
+// src/types/Exception.ts
+var Exception = class _Exception extends Enum {
+  constructor(message, id, reason) {
+    super(message, id ?? text(message).pascal.toString());
+    this.message = message;
+    this.reason = reason;
+  }
+  static AlreadyExists = new _Exception("Subject already exists");
+  static DoesNotExist = new _Exception("Does not exist");
+  static IsMissingId = new _Exception("Subject is missing an id");
+  static IsNotImplemented = new _Exception("Is not implemented");
+  static IsNotValid = new _Exception("Is not valid");
+  static Unknown = new _Exception("Unknown error");
+  static CouldNotExecute = (target) => new _Exception(`Could not execute ${target}.`, "CouldNotExecute");
+  static CouldNotValidate = (target) => new _Exception(`Could not validate ${target}.`, "CouldNotValidate");
+  static EnvironmentVariableNotFound = (variable) => new _Exception(`Environment variable ${text(variable).upper} could not be found.`, "EnvironmentVariableNotFound");
+  because = (reason) => new _Exception(this.message, this.id, reason);
+};
+var isException = (e, t) => e instanceof Exception && (isDefined(t) ? e.equals(asString(t)) : true);
+var isDoesNotExist = (e) => e instanceof Exception && Exception.DoesNotExist.equals(e);
+
+// src/validation/When.ts
+var When = class _When {
+  constructor(subject, valid = true, results) {
+    this.subject = subject;
+    this.valid = valid;
+    this.results = results;
+  }
+  get not() {
+    return this.clone(!this.valid);
+  }
+  get and() {
+    return this.clone(this.valid);
+  }
+  get isDefined() {
+    return this.clone(this.valid === isDefined(this.subject));
+  }
+  get isEmpty() {
+    return this.clone(this.valid === isEmpty(this.subject));
+  }
+  get isTrue() {
+    return this.clone(this.valid === !!this.subject);
+  }
+  get isValid() {
+    this.results = validate(this.subject);
+    return this.clone(this.valid === this.results.isValid);
+  }
+  isInstance = (c) => this.clone(this.valid === this.subject instanceof c);
+  with = (pred) => this.clone(this.valid === ofGet(pred, this.subject));
+  contains = (property) => this.clone(this.valid === isDefined(ofGet(property, this.subject)));
+  in = (...items) => this.clone(this.valid === isIn(this.subject, toArray(...items)));
+  is = (item) => this.clone(this.valid === (this.subject === item));
+  reject = (error) => !this.valid ? resolve(this.subject) : reject(ofGet(error, this.subject) ?? this.results ?? Exception.Unknown);
+  recover = (f) => resolve(!this.valid ? this.subject : f(this.subject));
+  clone = (result = true) => new _When(this.subject, result, this.results);
+};
+var when = (subject) => new When(subject);
+
 // src/types/Context.ts
 var DotEnvContext = class {
   domain = process.env.DOMAIN ?? "easy";
@@ -396,6 +580,29 @@ var Results = class {
 var toResults = (...r) => new Results(...r);
 var isResults = (r) => isDefined(r) && r instanceof Results;
 
+// src/validation/Validate.ts
+var asResults = (subject, template2, options = {}) => toResults(toResult(text(template2).parse(subject, options), toName(subject)));
+var validators = (subject) => meta(subject).keys("constraint").reduce((list, vs) => list.add(vs), toList());
+var runValidator = (v, subject) => {
+  try {
+    const actual = isFunction(subject[v.property]) ? subject[v.property]() : subject[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));
+  }
+};
+var constraints = (subject) => validators(subject).map((vs) => runValidator(vs, subject)).reduce((rs, r) => rs.add(...r.results), toResults());
+var validate = (subject) => choose(subject).is.not.defined(
+  (s) => s,
+  () => toResults("Subject is not defined.")
+).type(isEnum, (e) => e.isValid ? toResults() : asResults(e, "This is not a valid {typeof}.")).type(isValue, (v) => v.isValid ? toResults() : asResults(v, "This is not a valid {typeof}.")).type(isArray, (a) => a.map((i) => validate(i)).reduce((rs, r) => rs.add(...r.results), toResults())).type(isValidatable, (v) => constraints(v)).else(toResults());
+var validateReject = (subject) => when(subject).not.isValid.reject();
+var isValid = (t) => validate(t).isValid;
+
 // src/types/Case.ts
 var CaseBuilder = class {
   constructor(v) {
@@ -496,88 +703,320 @@ var Found = class extends Case {
 };
 var choose = (value) => new CaseBuilder(value);
 
-// src/validation/Validate.ts
-var asResults = (subject, template2, options = {}) => toResults(toResult(text(template2).parse(subject, options), toName(subject)));
-var validators = (subject) => meta(subject).keys("constraint").reduce((list, vs) => list.add(vs), toList());
-var runValidator = (v, subject) => {
-  try {
-    const actual = isFunction(subject[v.property]) ? subject[v.property]() : subject[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));
-  }
-};
-var constraints = (subject) => validators(subject).map((vs) => runValidator(vs, subject)).reduce((rs, r) => rs.add(...r.results), toResults());
-var validate = (subject) => choose(subject).is.not.defined(
-  (s) => s,
-  () => toResults("Subject is not defined.")
-).type(isEnum, (e) => e.isValid ? toResults() : asResults(e, "This is not a valid {typeof}.")).type(isValue, (v) => v.isValid ? toResults() : asResults(v, "This is not a valid {typeof}.")).type(isArray, (a) => a.map((i) => validate(i)).reduce((rs, r) => rs.add(...r.results), toResults())).type(isValidatable, (v) => constraints(v)).else(toResults());
-var validateReject = (subject) => when(subject).not.isValid.reject();
-var isValid = (t) => validate(t).isValid;
+// src/types/IsEqual.ts
+var isEqualArray = (one, another) => choose([one, another]).case(([o, a]) => !isArray(o) || !isArray(a), false).case(([o, a]) => o?.length !== a?.length, false).else(([o, a]) => !o.some((v, i) => !isEqual(v, a[i])));
+var isEqualObject = (one, another) => choose([Object.keys(one), Object.keys(another)]).case(([keysO, keysA]) => keysO.length !== keysA.length, false).case(([keysO, keysA]) => keysO.some((k) => !keysA.includes(k)), false).case(([keysO]) => keysO.some((k) => !isEqual(one[k], another[k])), false).else(true);
+var isEqual = (one, another) => choose([one, another]).case(([o, a]) => o === a, true).case(
+  ([o, a]) => isArray(o) || isArray(a),
+  ([o, a]) => isEqualArray(o, a)
+).case(
+  ([o, a]) => o == null || a == null || !isObject(o) && !isObject(a),
+  ([o, a]) => o !== o && a !== a
+).else(([o, a]) => isEqualObject(o, a));
 
-// src/types/Exception.ts
-var Exception = class _Exception extends Enum {
-  constructor(message, id, reason) {
-    super(message, id ?? text(message).pascal.toString());
-    this.message = message;
-    this.reason = reason;
-  }
-  static AlreadyExists = new _Exception("Subject already exists");
-  static DoesNotExist = new _Exception("Does not exist");
-  static IsMissingId = new _Exception("Subject is missing an id");
-  static IsNotImplemented = new _Exception("Is not implemented");
-  static IsNotValid = new _Exception("Is not valid");
-  static Unknown = new _Exception("Unknown error");
-  static CouldNotExecute = (target) => new _Exception(`Could not execute ${target}.`, "CouldNotExecute");
-  static CouldNotValidate = (target) => new _Exception(`Could not validate ${target}.`, "CouldNotValidate");
-  static EnvironmentVariableNotFound = (variable) => new _Exception(`Environment variable ${text(variable).upper} could not be found.`, "EnvironmentVariableNotFound");
-  because = (reason) => new _Exception(this.message, this.id, reason);
-};
-var isException = (e, t) => e instanceof Exception && (isDefined(t) ? e.equals(asString(t)) : true);
-var isDoesNotExist = (e) => e instanceof Exception && Exception.DoesNotExist.equals(e);
+// src/utils/If.ts
+function ifTrue(o, f, alt) {
+  return isTrue(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
+}
+function ifFalse(o, f, alt) {
+  return !isTrue(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
+}
+function ifDefined(o, f, alt) {
+  return isDefined(o) ? ofConstruct(f, o) : ofConstruct(alt);
+}
+function ifNotEmpty(o, f = (o2) => o2, alt) {
+  return isNotEmpty(o) ? ofConstruct(f, o) : ofConstruct(alt, o);
+}
+function ifEqual(one, another, f, alt) {
+  return isEqual(one, another) ? ofConstruct(f) : ofConstruct(alt);
+}
+function ifEither(os, f = (o) => o, alt) {
+  return use(
+    toList(os).first((o) => isPresent(o)),
+    (o) => isDefined(o) ? ofConstruct(f, o) : ofConstruct(alt, o)
+  );
+}
 
-// src/validation/When.ts
-var When = class _When {
-  constructor(subject, valid = true, results) {
-    this.subject = subject;
-    this.valid = valid;
-    this.results = results;
+// src/types/List.ts
+var List8 = class extends Array {
+  get ids() {
+    return this.mapDefined((i) => i.id);
   }
-  get not() {
-    return this.clone(!this.valid);
+  get indexed() {
+    return this.map((v, index) => ({ ...v, index }));
   }
-  get and() {
-    return this.clone(this.valid);
+  isSubSetOf(...items) {
+    return this.diff(items).length === 0;
   }
-  get isDefined() {
-    return this.clone(this.valid === isDefined(this.subject));
+  isSuperSetOf(...items) {
+    return this.length > items.length && toList(...items).isSubSetOf(...this);
   }
-  get isEmpty() {
-    return this.clone(this.valid === isEmpty(this.subject));
+  isIntersectingWith(...items) {
+    return this.intersect(items).length > 0;
   }
-  get isTrue() {
-    return this.clone(this.valid === !!this.subject);
+  isDisjointWith(...items) {
+    return !this.isIntersectingWith(...items);
   }
-  get isValid() {
-    this.results = validate(this.subject);
-    return this.clone(this.valid === this.results.isValid);
+  areEqual(...items) {
+    return this.isSubSetOf(...items) && toList(...items).isSubSetOf(...this);
+  }
+  asc(p) {
+    return toList(...this).sort((e1, e2) => ofProperty(e1, p) > ofProperty(e2, p) ? 1 : -1);
+  }
+  desc(p) {
+    return toList(...this).sort((e1, e2) => ofProperty(e1, p) < ofProperty(e2, p) ? 1 : -1);
+  }
+  first(p, params) {
+    return p ? this.find(p, params) : this[0];
+  }
+  firstValue(f, alt) {
+    return ifDefined(
+      this.first((t) => !!f(t)),
+      f,
+      (v) => ofGet(alt, v)
+    );
+  }
+  isFirst(value) {
+    return value === this.first();
+  }
+  next(p, params) {
+    return p ? this[this.findIndex(p, params) + 1] : this[0];
+  }
+  prev(p, params) {
+    return p ? this[this.findIndex(p, params) - 1] : this[0];
+  }
+  last(p, params) {
+    return p ? this.filter(p, params).last() : this[this.length - 1];
+  }
+  isLast(value) {
+    return value === this.last();
+  }
+  overlaps(...items) {
+    return toList(...items).some((i) => this.some((t) => i === t));
+  }
+  diff(others) {
+    return this.filter((i) => !others.includes(i));
+  }
+  diffByKey(others, key) {
+    return this.filter((i) => !others.some((o) => o[key] === i[key]));
+  }
+  symmetricDiff(others) {
+    return this.diff(others).concat(toList(...others).diff(this));
+  }
+  symmetricDiffByKey(others, key) {
+    return this.diffByKey(others, key).concat(toList(...others).diffByKey(this, key));
+  }
+  intersect(others) {
+    return this.filter((i) => others.includes(i));
+  }
+  intersectByKey(others, key) {
+    return this.filter((i) => others.some((o) => o[key] === i[key]));
+  }
+  intersectBy(others, f) {
+    return this.filter((i) => others.some((o) => f(i, o)));
+  }
+  accumulate(...keys2) {
+    return this.map((d, i, arr) => {
+      const acc = keys2.reduce((acc2, v) => {
+        acc2[v] = i === 0 ? d[v] : arr[i - 1][v] + d[v];
+        return acc2;
+      }, d);
+      arr[i] = acc;
+      return acc;
+    });
+  }
+  toJSON() {
+    return this.reduce((a, i) => {
+      a.push(JSON.parse(JSON.stringify(i ?? {})));
+      return a;
+    }, new Array());
+  }
+  map(f, params) {
+    return toList(super.map(f, params));
+  }
+  flatMap(f, params) {
+    return toList(super.flatMap(f, params));
+  }
+  mapDefined(f, params) {
+    return this.map(f, params).defined();
+  }
+  mapAsync(f) {
+    return Promise.all(super.map((e) => f(e))).then((a) => toList(a));
+  }
+  mapSerial(f) {
+    return super.reduce((p, item) => p.then((results) => on(results, async (r) => r.push(await f(item)))), Promise.resolve(toList()));
+  }
+  distinct() {
+    return this.filter((i, index) => this.indexOf(i) === index);
+  }
+  distinctByKey(key) {
+    const seen = /* @__PURE__ */ new Set();
+    return this.filter((item) => !seen.has(item[key]) && seen.add(item[key]));
+  }
+  distinctByValue() {
+    const seen = /* @__PURE__ */ new Set();
+    return this.filter((item) => !seen.has(JSON.stringify(item)) && seen.add(JSON.stringify(item)));
+  }
+  filter(p, params) {
+    return toList(super.filter(p, params));
+  }
+  sum(p) {
+    return this.reduce((sum, i) => sum + p(i), 0);
+  }
+  max(p) {
+    return this.desc(p).first();
+  }
+  min(p) {
+    return this.asc(p).first();
+  }
+  byId(id) {
+    return this.first((i) => equals(i.id, id));
+  }
+  byKey(key, value) {
+    return this.first((i) => i[key] == value);
+  }
+  add(...items) {
+    super.push(...toArray(...items));
+    return this;
+  }
+  concat(...items) {
+    return toList(super.concat(...items));
+  }
+  reverse() {
+    return toList(super.reverse());
+  }
+  splice(start, deleteCount, ...items) {
+    return toList(super.splice(start, deleteCount, ...items));
+  }
+  remove(item) {
+    const index = this.indexOf(item);
+    if (index > -1) {
+      this.splice(index, 1);
+    }
+    return this;
+  }
+  move(sourceId, destinationId) {
+    return this.moveOn("id", sourceId, destinationId);
+  }
+  moveOn(key, sourceId, destinationId) {
+    const source = this.findIndex((i) => equals(i[key], sourceId));
+    const dest = this.findIndex((i) => equals(i[key], destinationId));
+    return on(toList(...this), (r) => r.splice(dest, 0, ...r.splice(source, 1)));
+  }
+  replace(key, item) {
+    const index = this.findIndex((i) => i[key] === item?.[key]);
+    ifTrue(index != -1, () => this.splice(index, 1, item));
+    return this;
+  }
+  switch(item) {
+    return this.includes(item) ? this.remove(item) : this.add(item);
+  }
+  switchOn(item, on2) {
+    return use(
+      typeof on2 === "function" ? this.find(on2) : use(traverse(item, on2), (v) => this.find((i) => traverse(i, on2) === v)),
+      (i) => i ? this.remove(i) : this.add(item)
+    );
+  }
+  defined() {
+    return this.reduce((l, v) => isDefined(v) ? l.add(v) : l, toList());
+  }
+  toObject(key, options = {}) {
+    return this.reduce((o, i) => {
+      o[i[key]] = i;
+      if (options.deleteKey)
+        delete o[i[key]][key];
+      return o;
+    }, {});
+  }
+  toObjectList(key) {
+    return this.reduce(
+      (a, t) => {
+        const k = t[key];
+        a[k] = a[k] ?? toList();
+        a[k].push(t);
+        return a;
+      },
+      {}
+    );
+  }
+  orElse(...alt) {
+    return !isEmpty(this) ? this : !isEmpty(...alt) ? toList(...alt) : void 0;
+  }
+  weave(insertFrom, interval) {
+    for (let i = interval, n = 0; i <= this.length && n < insertFrom.length; i += interval + 1) {
+      this.splice(i, 0, insertFrom[n++]);
+    }
+    return this;
+  }
+  slice(start, end) {
+    return toList(super.slice(start, end));
+  }
+  none(p) {
+    return !this.some(p);
+  }
+  chunk(chunkSize) {
+    return this.reduce((acc, _, index) => index % chunkSize === 0 ? on(acc, (a) => a.push(this.slice(index, index + chunkSize))) : acc, toList());
+  }
+  //we needed to add U because of a Typescript issue with generics
+  update(p, val) {
+    return this.map((v, i, a) => p(v, i, a) ? ofGet(val, v, i, a) : v);
+  }
+  updateFirst(p, val) {
+    const index = this.findIndex(p);
+    return this.update((t, i) => p(t, i, this) && i == index, val);
+  }
+  updateFirstById(id, val) {
+    return this.updateFirst((i) => equals(i?.id, id), val);
+  }
+  updateById(id, val) {
+    return this.update((i) => equals(i?.id, id), val);
+  }
+  groupBy(by) {
+    return toList(
+      Array.from(this.reduce((m, v, i, a) => use(by(v, i, a), (key) => m.set(key, (m.get(key) ?? toList()).add(v))), /* @__PURE__ */ new Map()).values())
+    );
   }
-  isInstance = (c) => this.clone(this.valid === this.subject instanceof c);
-  with = (pred) => this.clone(this.valid === ofGet(pred, this.subject));
-  contains = (property) => this.clone(this.valid === isDefined(ofGet(property, this.subject)));
-  in = (...items) => this.clone(this.valid === isIn(this.subject, toArray(...items)));
-  is = (item) => this.clone(this.valid === (this.subject === item));
-  reject = (error) => !this.valid ? resolve(this.subject) : reject(ofGet(error, this.subject) ?? this.results ?? Exception.Unknown);
-  recover = (f) => resolve(!this.valid ? this.subject : f(this.subject));
-  clone = (result = true) => new _When(this.subject, result, this.results);
 };
-var when = (subject) => new When(subject);
+var toList = (...items) => new List8().add(...items);
+var isList = (l) => isDefined(l) && isArray(l) && isA(l, "first", "last", "asc", "desc");
+var asList = (c, items = []) => toList(toArray(items).map((i) => new c(i)));
+var maxValue = (l, key) => l.desc(key).first()?.[key];
+var minValue = (l, key) => l.asc(key).first()?.[key];
 
 export {
+  List8 as List,
+  toList,
+  isList,
+  asList,
+  maxValue,
+  minValue,
+  entries,
+  values,
+  keys,
+  extractKeys,
+  resolve,
+  reject,
+  tuple,
+  tuple2,
+  tuple3,
+  tuple4,
+  tuple5,
+  tupleO,
+  settled,
+  meta,
+  isEnumConstructor,
+  Enum,
+  isEnum,
+  Try,
+  tryTo,
+  Template,
+  template,
+  ToText,
+  text,
+  textValue,
+  Exception,
+  isException,
+  isDoesNotExist,
   When,
   when,
   DotEnvContext,
@@ -590,20 +1029,17 @@ export {
   Results,
   toResults,
   isResults,
-  choose,
   asResults,
   validate,
   validateReject,
   isValid,
-  Try,
-  tryTo,
-  Template,
-  template,
-  ToText,
-  text,
-  textValue,
-  Exception,
-  isException,
-  isDoesNotExist
+  choose,
+  isEqual,
+  ifTrue,
+  ifFalse,
+  ifDefined,
+  ifNotEmpty,
+  ifEqual,
+  ifEither
 };
-//# sourceMappingURL=chunk-UL2QXFW5.mjs.map
+//# sourceMappingURL=chunk-TUO7ZPSP.mjs.map