@zelgadis87/utils-core 5.2.1 → 5.2.3

package/esbuild/index.cjs

@@ -182,6 +182,7 @@ __export(index_exports, {
   LazyDictionary: () => LazyDictionary,
   Logger: () => Logger,
   NEVER: () => NEVER,
+  NonExhaustiveSwitchError: () => NonExhaustiveSwitchError,
   Optional: () => Optional,
   PredicateBuilder: () => PredicateBuilder,
   RandomTimeDuration: () => RandomTimeDuration,
@@ -237,6 +238,7 @@ __export(index_exports, {
   filterMap: () => filterMap,
   filterMapReduce: () => filterMapReduce,
   filterWithTypePredicate: () => filterWithTypePredicate,
+  findInArray: () => findInArray,
   first: () => first,
   flatMapTruthys: () => flatMapTruthys,
   getCauseMessageFromError: () => getCauseMessageFromError,
@@ -338,11 +340,13 @@ __export(index_exports, {
   uniq: () => uniq,
   uniqBy: () => uniqBy,
   uniqByKey: () => uniqByKey,
+  unzip: () => unzip,
   upsert: () => upsert,
   withTryCatch: () => withTryCatch,
   withTryCatchAsync: () => withTryCatchAsync,
   wrapWithString: () => wrapWithString,
-  xor: () => xor
+  xor: () => xor,
+  zip: () => zip
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -541,6 +545,179 @@ function throwIfNullOrUndefined(source, errorProducer = () => new Error(`Unexpec
   });
 }
 
+// src/Optional.ts
+var Optional = class _Optional {
+  _present;
+  _value;
+  constructor(t) {
+    const defined = isDefined(t);
+    this._value = defined ? t : void 0;
+    this._present = defined;
+  }
+  getRawValue() {
+    return this._value;
+  }
+  get() {
+    return this.getOrElseThrow(() => new ErrorGetEmptyOptional());
+  }
+  getOrElseThrow(errorProducer) {
+    if (this.isEmpty())
+      throw errorProducer();
+    return this._value;
+  }
+  set(t) {
+    if (isNullOrUndefined(t))
+      throw new ErrorSetEmptyOptional();
+    this._value = t;
+    this._present = true;
+  }
+  setNullable(t) {
+    if (isDefined(t)) {
+      return this.set(t);
+    }
+    return this;
+  }
+  clear() {
+    this._value = void 0;
+    this._present = false;
+  }
+  isEmpty() {
+    return !this._present;
+  }
+  isPresent() {
+    return this._present;
+  }
+  ifEmpty(callback) {
+    if (this.isEmpty())
+      callback();
+  }
+  ifPresent(callback) {
+    if (this.isPresent())
+      callback(this.get());
+  }
+  ifPresentThenClear(callback) {
+    if (this.isPresent()) {
+      callback(this.get());
+      this.clear();
+    }
+  }
+  apply(callbackIfPresent, callbackIfEmpty) {
+    if (this.isEmpty()) {
+      callbackIfEmpty();
+    } else {
+      callbackIfPresent(this.get());
+    }
+  }
+  orElseReturn(newValue) {
+    if (this.isPresent()) {
+      return this.get();
+    } else {
+      return newValue;
+    }
+  }
+  orElse = this.orElseReturn.bind(this);
+  orElseProduce(newValueProducer) {
+    if (this.isPresent()) {
+      return this.get();
+    } else {
+      return newValueProducer();
+    }
+  }
+  orElseGet = this.orElseProduce.bind(this);
+  orElseReturnAndApply(newValue) {
+    if (this.isPresent()) {
+      return this.get();
+    } else {
+      this.set(newValue);
+      return newValue;
+    }
+  }
+  orElseProduceAndApply(newValueProducer) {
+    if (this.isPresent()) {
+      return this.get();
+    } else {
+      const newValue = newValueProducer();
+      this.set(newValue);
+      return newValue;
+    }
+  }
+  orElseReturnNullableAndApply(newValue) {
+    if (this.isPresent()) {
+      return this;
+    } else {
+      this.setNullable(newValue);
+      return this;
+    }
+  }
+  orElseProduceNullableAndApply(newValueProducer) {
+    if (this.isPresent()) {
+      return this;
+    } else {
+      const newValue = newValueProducer();
+      this.setNullable(newValue);
+      return this;
+    }
+  }
+  orElseReturnNullable(newValue) {
+    if (this.isEmpty()) return _Optional.ofNullable(newValue);
+    return this;
+  }
+  orElseNullable = this.orElseReturnNullable.bind(this);
+  orElseProduceNullable(newValueProducer) {
+    if (this.isEmpty()) {
+      const newValue = newValueProducer();
+      return _Optional.ofNullable(newValue);
+    }
+    return this;
+  }
+  orElseGetNullable = this.orElseProduceNullable.bind(this);
+  orElseThrow(errorProducer) {
+    if (this.isEmpty())
+      throw errorProducer();
+    return this;
+  }
+  mapTo(mapper) {
+    return this.flatMapTo((t) => _Optional.ofNullable(mapper(t)));
+  }
+  flatMapTo(mapper) {
+    return this.isPresent() ? mapper(this.get()) : _Optional.empty();
+  }
+  filter(predicate) {
+    if (this.isEmpty())
+      return this;
+    if (predicate(this.get()))
+      return this;
+    return _Optional.empty();
+  }
+  static empty() {
+    return new _Optional(void 0);
+  }
+  static of(t) {
+    if (isNullOrUndefined(t))
+      throw new ErrorCannotInstantiatePresentOptionalWithEmptyValue();
+    return new _Optional(t);
+  }
+  static ofNullable(t) {
+    return new _Optional(t);
+  }
+};
+var Optional_default = Optional;
+var ErrorGetEmptyOptional = class extends Error {
+  constructor() {
+    super("Cannot retrieve a value from an empty Optional.");
+  }
+};
+var ErrorSetEmptyOptional = class extends Error {
+  constructor() {
+    super("Cannot set a null or undefined value.");
+  }
+};
+var ErrorCannotInstantiatePresentOptionalWithEmptyValue = class extends Error {
+  constructor() {
+    super("Cannot initialize a PresentOptional with a null or undefined value.");
+  }
+};
+
 // src/utils/arrays/groupBy.ts
 function groupByString(arr, field) {
   return groupByStringWith(arr, (t) => t[field]);
@@ -600,8 +777,12 @@ function indexBySymbolWith(arr, getter) {
 function doIndexByWith(arr, getter) {
   return arr.reduce((dict, cur) => {
     const key = getter(cur);
-    if (key !== null && key !== void 0)
+    if (key !== null && key !== void 0) {
+      if (dict[key]) {
+        throw new Error(`Multiple values indexed by same key "${String(key)}".`);
+      }
       dict[key] = cur;
+    }
     return dict;
   }, {});
 }
@@ -860,6 +1041,19 @@ function shallowArrayEquals(a, b) {
   }
   return true;
 }
+function findInArray(arr, predicate) {
+  return Optional_default.ofNullable(arr.find(predicate));
+}
+function zip(ts, rs) {
+  if (ts.length !== rs.length)
+    throw new Error(`Arrays must have the same length. Got ${ts.length} and ${rs.length}`);
+  return ts.map((t, i) => [t, rs[i]]);
+}
+function unzip(arr) {
+  return arr.reduce(([ts, rs], [t, r]) => {
+    return [[...ts, t], [...rs, r]];
+  }, [[], []]);
+}
 
 // src/utils/booleans.ts
 function isTrue(x) {
@@ -972,6 +1166,11 @@ function getCauseStackFromError(error) {
   return `
 caused by: ${getStackFromError(asError(error.cause))}`;
 }
+var NonExhaustiveSwitchError = class extends Error {
+  constructor(value) {
+    super("Expected switch to be exhaustive, got: " + value);
+  }
+};
 
 // src/utils/json.ts
 function tryToParseJson(jsonContent) {
@@ -2311,178 +2510,6 @@ var Logger = class {
   }
 };
 
-// src/Optional.ts
-var Optional = class _Optional {
-  _present;
-  _value;
-  constructor(t) {
-    const defined = isDefined(t);
-    this._value = defined ? t : void 0;
-    this._present = defined;
-  }
-  getRawValue() {
-    return this._value;
-  }
-  get() {
-    return this.getOrElseThrow(() => new ErrorGetEmptyOptional());
-  }
-  getOrElseThrow(errorProducer) {
-    if (this.isEmpty())
-      throw errorProducer();
-    return this._value;
-  }
-  set(t) {
-    if (isNullOrUndefined(t))
-      throw new ErrorSetEmptyOptional();
-    this._value = t;
-    this._present = true;
-  }
-  setNullable(t) {
-    if (isDefined(t)) {
-      return this.set(t);
-    }
-    return this;
-  }
-  clear() {
-    this._value = void 0;
-    this._present = false;
-  }
-  isEmpty() {
-    return !this._present;
-  }
-  isPresent() {
-    return this._present;
-  }
-  ifEmpty(callback) {
-    if (this.isEmpty())
-      callback();
-  }
-  ifPresent(callback) {
-    if (this.isPresent())
-      callback(this.get());
-  }
-  ifPresentThenClear(callback) {
-    if (this.isPresent()) {
-      callback(this.get());
-      this.clear();
-    }
-  }
-  apply(callbackIfPresent, callbackIfEmpty) {
-    if (this.isEmpty()) {
-      callbackIfEmpty();
-    } else {
-      callbackIfPresent(this.get());
-    }
-  }
-  orElseReturn(newValue) {
-    if (this.isPresent()) {
-      return this.get();
-    } else {
-      return newValue;
-    }
-  }
-  orElse = this.orElseReturn.bind(this);
-  orElseProduce(newValueProducer) {
-    if (this.isPresent()) {
-      return this.get();
-    } else {
-      return newValueProducer();
-    }
-  }
-  orElseGet = this.orElseProduce.bind(this);
-  orElseReturnAndApply(newValue) {
-    if (this.isPresent()) {
-      return this.get();
-    } else {
-      this.set(newValue);
-      return newValue;
-    }
-  }
-  orElseProduceAndApply(newValueProducer) {
-    if (this.isPresent()) {
-      return this.get();
-    } else {
-      const newValue = newValueProducer();
-      this.set(newValue);
-      return newValue;
-    }
-  }
-  orElseReturnNullableAndApply(newValue) {
-    if (this.isPresent()) {
-      return this;
-    } else {
-      this.setNullable(newValue);
-      return this;
-    }
-  }
-  orElseProduceNullableAndApply(newValueProducer) {
-    if (this.isPresent()) {
-      return this;
-    } else {
-      const newValue = newValueProducer();
-      this.setNullable(newValue);
-      return this;
-    }
-  }
-  orElseReturnNullable(newValue) {
-    if (this.isEmpty()) return _Optional.ofNullable(newValue);
-    return this;
-  }
-  orElseNullable = this.orElseReturnNullable.bind(this);
-  orElseProduceNullable(newValueProducer) {
-    if (this.isEmpty()) {
-      const newValue = newValueProducer();
-      return _Optional.ofNullable(newValue);
-    }
-    return this;
-  }
-  orElseGetNullable = this.orElseProduceNullable.bind(this);
-  orElseThrow(errorProducer) {
-    if (this.isEmpty())
-      throw errorProducer();
-    return this;
-  }
-  mapTo(mapper) {
-    return this.flatMapTo((t) => _Optional.ofNullable(mapper(t)));
-  }
-  flatMapTo(mapper) {
-    return this.isPresent() ? mapper(this.get()) : _Optional.empty();
-  }
-  filter(predicate) {
-    if (this.isEmpty())
-      return this;
-    if (predicate(this.get()))
-      return this;
-    return _Optional.empty();
-  }
-  static empty() {
-    return new _Optional(void 0);
-  }
-  static of(t) {
-    if (isNullOrUndefined(t))
-      throw new ErrorCannotInstantiatePresentOptionalWithEmptyValue();
-    return new _Optional(t);
-  }
-  static ofNullable(t) {
-    return new _Optional(t);
-  }
-};
-var ErrorGetEmptyOptional = class extends Error {
-  constructor() {
-    super("Cannot retrieve a value from an empty Optional.");
-  }
-};
-var ErrorSetEmptyOptional = class extends Error {
-  constructor() {
-    super("Cannot set a null or undefined value.");
-  }
-};
-var ErrorCannotInstantiatePresentOptionalWithEmptyValue = class extends Error {
-  constructor() {
-    super("Cannot initialize a PresentOptional with a null or undefined value.");
-  }
-};
-
 // src/sorting/Sorter.ts
 var defaultCompareValuesOptions = {
   nullsFirst: false
@@ -2609,7 +2636,7 @@ var next = (fns, transform) => {
       return compareNumbers(fns, transform, { direction: "DESC", ...opts });
     }
   };
-  const retForStrings = {
+  const retForStringsV1 = {
     ...retAsUsing,
     inLexographicalOrder(opts = {}) {
       return compareStrings(fns, transform, { direction: "ASC", ignoreCase: false, ...opts });
@@ -2624,6 +2651,22 @@ var next = (fns, transform) => {
       return compareStrings(fns, transform, { direction: "DESC", ignoreCase: true, ...opts });
     }
   };
+  const retForStrings = {
+    ...retAsUsing,
+    ...retForStringsV1,
+    inLexicographicalOrder(opts = {}) {
+      return compareStrings(fns, transform, { direction: "ASC", ignoreCase: false, ...opts });
+    },
+    inLexicographicalOrderIgnoringCase(opts = {}) {
+      return compareStrings(fns, transform, { direction: "ASC", ignoreCase: true, ...opts });
+    },
+    inReverseLexicographicalOrder(opts = {}) {
+      return compareStrings(fns, transform, { direction: "DESC", ignoreCase: false, ...opts });
+    },
+    inReverseLexicographicalOrderIgnoringCase(opts = {}) {
+      return compareStrings(fns, transform, { direction: "DESC", ignoreCase: true, ...opts });
+    }
+  };
   const retForBooleans = {
     ...retAsUsing,
     truesFirst(opts = {}) {
@@ -2951,6 +2994,7 @@ function isUpgradable(obj) {
   LazyDictionary,
   Logger,
   NEVER,
+  NonExhaustiveSwitchError,
   Optional,
   PredicateBuilder,
   RandomTimeDuration,
@@ -3006,6 +3050,7 @@ function isUpgradable(obj) {
   filterMap,
   filterMapReduce,
   filterWithTypePredicate,
+  findInArray,
   first,
   flatMapTruthys,
   getCauseMessageFromError,
@@ -3107,10 +3152,12 @@ function isUpgradable(obj) {
   uniq,
   uniqBy,
   uniqByKey,
+  unzip,
   upsert,
   withTryCatch,
   withTryCatchAsync,
   wrapWithString,
-  xor
+  xor,
+  zip
 });
 //# sourceMappingURL=index.cjs.map