effect 2.0.0-next.42 → 2.0.0-next.43

package/ReadonlyRecord/dist/effect-ReadonlyRecord.cjs.dev.js

@@ -2,45 +2,555 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('../../dist/Either-a806809d.cjs.dev.js');
-require('../../dist/Function-41ce433d.cjs.dev.js');
-require('../../dist/Option-03997d77.cjs.dev.js');
-var ReadonlyRecord_dist_effectReadonlyRecord = require('../../dist/ReadonlyRecord-605a625b.cjs.dev.js');
-require('../../dist/Equivalence-de7a0d51.cjs.dev.js');
-require('../../dist/Either-9c349424.cjs.dev.js');
-require('../../dist/Equal-281b6ca8.cjs.dev.js');
-require('../../dist/Hash-bd154268.cjs.dev.js');
-require('../../dist/GlobalValue-81ab6908.cjs.dev.js');
-require('../../dist/Utils-b0c14d1b.cjs.dev.js');
-require('../../dist/Predicate-9e859c9c.cjs.dev.js');
-require('../../dist/Inspectable-ac929af4.cjs.dev.js');
-require('../../dist/Effectable-a6403e5f.cjs.dev.js');
-require('../../dist/Data-85559fb3.cjs.dev.js');
-require('../../dist/Pipeable-4698db72.cjs.dev.js');
-require('../../dist/Number-588f6483.cjs.dev.js');
-require('../../dist/Order-28bdebd2.cjs.dev.js');
-
-
-
-exports.collect = ReadonlyRecord_dist_effectReadonlyRecord.collect;
-exports.compact = ReadonlyRecord_dist_effectReadonlyRecord.compact;
-exports.empty = ReadonlyRecord_dist_effectReadonlyRecord.empty;
-exports.filter = ReadonlyRecord_dist_effectReadonlyRecord.filter;
-exports.filterMap = ReadonlyRecord_dist_effectReadonlyRecord.filterMap;
-exports.fromEntries = ReadonlyRecord_dist_effectReadonlyRecord.fromEntries;
-exports.fromIterable = ReadonlyRecord_dist_effectReadonlyRecord.fromIterable;
-exports.get = ReadonlyRecord_dist_effectReadonlyRecord.get;
-exports.has = ReadonlyRecord_dist_effectReadonlyRecord.has;
-exports.isEmptyReadonlyRecord = ReadonlyRecord_dist_effectReadonlyRecord.isEmptyReadonlyRecord;
-exports.isEmptyRecord = ReadonlyRecord_dist_effectReadonlyRecord.isEmptyRecord;
-exports.map = ReadonlyRecord_dist_effectReadonlyRecord.map;
-exports.modifyOption = ReadonlyRecord_dist_effectReadonlyRecord.modifyOption;
-exports.partition = ReadonlyRecord_dist_effectReadonlyRecord.partition;
-exports.partitionMap = ReadonlyRecord_dist_effectReadonlyRecord.partitionMap;
-exports.pop = ReadonlyRecord_dist_effectReadonlyRecord.pop;
-exports.remove = ReadonlyRecord_dist_effectReadonlyRecord.remove;
-exports.replaceOption = ReadonlyRecord_dist_effectReadonlyRecord.replaceOption;
-exports.separate = ReadonlyRecord_dist_effectReadonlyRecord.separate;
-exports.size = ReadonlyRecord_dist_effectReadonlyRecord.size;
-exports.toArray = ReadonlyRecord_dist_effectReadonlyRecord.toArray;
-exports.toEntries = ReadonlyRecord_dist_effectReadonlyRecord.toEntries;
+var Either_dist_effectEither = require('../../Either/dist/effect-Either.cjs.dev.js');
+var Function_dist_effectFunction = require('../../Function/dist/effect-Function.cjs.dev.js');
+var Option_dist_effectOption = require('../../Option/dist/effect-Option.cjs.dev.js');
+require('../../Equivalence/dist/effect-Equivalence.cjs.dev.js');
+require('../../dist/Either-12bbe00c.cjs.dev.js');
+require('../../Equal/dist/effect-Equal.cjs.dev.js');
+require('../../Hash/dist/effect-Hash.cjs.dev.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.dev.js');
+require('../../Utils/dist/effect-Utils.cjs.dev.js');
+require('../../Predicate/dist/effect-Predicate.cjs.dev.js');
+require('../../Inspectable/dist/effect-Inspectable.cjs.dev.js');
+require('../../dist/Effectable-2f022879.cjs.dev.js');
+require('../../Data/dist/effect-Data.cjs.dev.js');
+require('../../Pipeable/dist/effect-Pipeable.cjs.dev.js');
+require('../../Number/dist/effect-Number.cjs.dev.js');
+require('../../Order/dist/effect-Order.cjs.dev.js');
+
+/**
+ * This module provides utility functions for working with records in TypeScript.
+ *
+ * @since 2.0.0
+ */
+
+// -------------------------------------------------------------------------------------
+// models
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+/**
+ * Creates a new, empty record.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const empty = () => ({});
+
+// -------------------------------------------------------------------------------------
+// guards
+// -------------------------------------------------------------------------------------
+
+/**
+ * Determine if a `Record` is empty.
+ *
+ * @param self - `Record` to test for emptiness.
+ *
+ * @example
+ * import { isEmptyRecord } from "effect/ReadonlyRecord"
+ *
+ * assert.deepStrictEqual(isEmptyRecord({}), true);
+ * assert.deepStrictEqual(isEmptyRecord({ a: 3 }), false);
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isEmptyRecord = self => {
+  for (const k in self) {
+    if (has(self, k)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * Determine if a `ReadonlyRecord` is empty.
+ *
+ * @param self - `ReadonlyRecord` to test for emptiness.
+ *
+ * @example
+ * import { isEmptyReadonlyRecord } from "effect/ReadonlyRecord"
+ *
+ * assert.deepStrictEqual(isEmptyReadonlyRecord({}), true);
+ * assert.deepStrictEqual(isEmptyReadonlyRecord({ a: 3 }), false);
+ *
+ * @category guards
+ * @since 2.0.0
+ */
+const isEmptyReadonlyRecord = isEmptyRecord;
+
+// -------------------------------------------------------------------------------------
+// conversions
+// -------------------------------------------------------------------------------------
+
+/**
+ * Takes an iterable and a projection function and returns a record.
+ * The projection function maps each value of the iterable to a tuple of a key and a value, which is then added to the resulting record.
+ *
+ * @param self - An iterable of values to be mapped to a record.
+ * @param f - A projection function that maps values of the iterable to a tuple of a key and a value.
+ *
+ * @example
+ * import { fromIterable } from 'effect/ReadonlyRecord'
+ *
+ * const input = [1, 2, 3, 4]
+ *
+ * assert.deepStrictEqual(
+ *   fromIterable(input, a => [String(a), a * 2]),
+ *   { '1': 2, '2': 4, '3': 6, '4': 8 }
+ * )
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+const fromIterable = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const out = {};
+  for (const a of self) {
+    const [k, b] = f(a);
+    out[k] = b;
+  }
+  return out;
+});
+
+/**
+ * Builds a record from an iterable of key-value pairs.
+ *
+ * If there are conflicting keys when using `fromEntries`, the last occurrence of the key/value pair will overwrite the
+ * previous ones. So the resulting record will only have the value of the last occurrence of each key.
+ *
+ * @param self - The iterable of key-value pairs.
+ *
+ * @example
+ * import { fromEntries } from 'effect/ReadonlyRecord'
+ *
+ * const input: Array<[string, number]> = [["a", 1], ["b", 2]]
+ *
+ * assert.deepStrictEqual(fromEntries(input), { a: 1, b: 2 })
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+const fromEntries = /*#__PURE__*/fromIterable(Function_dist_effectFunction.identity);
+
+/**
+ * Transforms the values of a `ReadonlyRecord` into an `Array` with a custom mapping function.
+ *
+ * @param self - The `ReadonlyRecord` to transform.
+ * @param f - The custom mapping function to apply to each key/value of the `ReadonlyRecord`.
+ *
+ * @example
+ * import { collect } from "effect/ReadonlyRecord"
+ *
+ * const x = { a: 1, b: 2, c: 3 }
+ * assert.deepStrictEqual(collect(x, (key, n) => [key, n]), [["a", 1], ["b", 2], ["c", 3]])
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+const collect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const out = [];
+  for (const key of Object.keys(self)) {
+    out.push(f(key, self[key]));
+  }
+  return out;
+});
+
+/**
+ * Takes a record and returns an array of tuples containing its keys and values.
+ *
+ * @param self - The record to transform.
+ *
+ * @example
+ * import { toEntries } from "effect/ReadonlyRecord"
+ *
+ * const x = { a: 1, b: 2, c: 3 }
+ * assert.deepStrictEqual(toEntries(x), [["a", 1], ["b", 2], ["c", 3]])
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+const toEntries = /*#__PURE__*/collect((key, value) => [key, value]);
+
+/**
+ * Takes a record and returns an array of tuples containing its keys and values.
+ *
+ * Alias of {@link toEntries}.
+ *
+ * @param self - The record to transform.
+ *
+ * @example
+ * import { toArray } from "effect/ReadonlyRecord"
+ *
+ * const x = { a: 1, b: 2, c: 3 }
+ * assert.deepStrictEqual(toArray(x), [["a", 1], ["b", 2], ["c", 3]])
+ *
+ * @category conversions
+ * @since 2.0.0
+ */
+const toArray = toEntries;
+
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+
+/**
+ * Returns the number of key/value pairs in a `ReadonlyRecord`.
+ *
+ * @param self - A `ReadonlyRecord` to calculate the number of key/value pairs in.
+ *
+ * @example
+ * import { size } from "effect/ReadonlyRecord";
+ *
+ * assert.deepStrictEqual(size({ a: "a", b: 1, c: true }), 3);
+ *
+ * @since 2.0.0
+ */
+const size = self => Object.keys(self).length;
+
+/**
+ * Check if a given `key` exists in a `ReadonlyRecord`.
+ *
+ * @param self - the `ReadonlyRecord` to look in.
+ * @param key - the key to look for in the `ReadonlyRecord`.
+ *
+ * @example
+ * import { has } from 'effect/ReadonlyRecord'
+ *
+ * assert.deepStrictEqual(has({ a: 1, b: 2 }, "a"), true);
+ * assert.deepStrictEqual(has({ a: 1, b: 2 }, "c"), false);
+ *
+ * @since 2.0.0
+ */
+const has = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => Object.prototype.hasOwnProperty.call(self, key));
+
+/**
+ * Retrieve a value at a particular key from a `ReadonlyRecord`, returning it wrapped in an `Option`.
+ *
+ * @param self - The `ReadonlyRecord` to retrieve value from.
+ * @param key - Key to retrieve from `ReadonlyRecord`.
+ *
+ * @example
+ * import { get } from "effect/ReadonlyRecord"
+ * import { some, none } from "effect/Option"
+ *
+ * const person = { name: "John Doe", age: 35 }
+ *
+ * assert.deepStrictEqual(get(person, "name"), some("John Doe"))
+ * assert.deepStrictEqual(get(person, "email"), none())
+ *
+ * @since 2.0.0
+ */
+const get = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => has(self, key) ? Option_dist_effectOption.some(self[key]) : Option_dist_effectOption.none());
+
+/**
+ * Apply a function to the element at the specified key, creating a new record,
+ * or return `None` if the key doesn't exist.
+ *
+ * @param self - The `ReadonlyRecord` to be updated.
+ * @param key - The key of the element to modify.
+ * @param f - The function to apply to the element.
+ *
+ * @example
+ * import { modifyOption } from "effect/ReadonlyRecord"
+ * import { some, none } from "effect/Option"
+ *
+ * const f = (x: number) => x * 2
+ *
+ * assert.deepStrictEqual(
+ *  modifyOption({ a: 3 }, 'a', f),
+ *  some({ a: 6 })
+ * )
+ * assert.deepStrictEqual(
+ *  modifyOption({ a: 3 }, 'b', f),
+ *  none()
+ * )
+ *
+ * @since 2.0.0
+ */
+const modifyOption = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, key, f) => {
+  if (!has(self, key)) {
+    return Option_dist_effectOption.none();
+  }
+  const out = {
+    ...self
+  };
+  out[key] = f(self[key]);
+  return Option_dist_effectOption.some(out);
+});
+
+/**
+ * Replaces a value in the record with the new value passed as parameter.
+ *
+ * @param self - The `ReadonlyRecord` to be updated.
+ * @param key - The key to search for in the record.
+ * @param b - The new value to replace the existing value with.
+ *
+ * @example
+ * import { replaceOption } from "effect/ReadonlyRecord"
+ * import { some, none } from "effect/Option"
+ *
+ * assert.deepStrictEqual(
+ *   replaceOption({ a: 1, b: 2, c: 3 }, 'a', 10),
+ *   some({ a: 10, b: 2, c: 3 })
+ * )
+ * assert.deepStrictEqual(replaceOption({}, 'a', 10), none())
+ *
+ * @since 2.0.0
+ */
+const replaceOption = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, key, b) => modifyOption(self, key, () => b));
+
+/**
+ * Removes a key from a `ReadonlyRecord` and returns a new `Record`
+ *
+ * @param self - the `ReadonlyRecord` to remove the key from.
+ * @param key - the key to remove from the `ReadonlyRecord`.
+ *
+ * @example
+ * import { remove } from 'effect/ReadonlyRecord'
+ *
+ * assert.deepStrictEqual(remove({ a: 1, b: 2 }, "a"), { b: 2 })
+ *
+ * @since 2.0.0
+ */
+const remove = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => {
+  const out = {
+    ...self
+  };
+  delete out[key];
+  return out;
+});
+
+/**
+ * Retrieves the value of the property with the given `key` from a `ReadonlyRecord` and returns an `Option`
+ * of a tuple with the value and the `ReadonlyRecord` with the removed property.
+ * If the key is not present, returns `O.none`.
+ *
+ * @param self - The input `ReadonlyRecord`.
+ * @param key - The key of the property to retrieve.
+ *
+ * @example
+ * import { pop } from 'effect/ReadonlyRecord'
+ * import { some, none } from 'effect/Option'
+ *
+ * assert.deepStrictEqual(pop({ a: 1, b: 2 }, "a"), some([1, { b: 2 }]))
+ * assert.deepStrictEqual(pop({ a: 1, b: 2 }, "c"), none())
+ *
+ * @category record
+ * @since 2.0.0
+ */
+const pop = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, key) => has(self, key) ? Option_dist_effectOption.some([self[key], remove(self, key)]) : Option_dist_effectOption.none());
+
+/**
+ * Maps a `ReadonlyRecord` into another `Record` by applying a transformation function to each of its values.
+ *
+ * @param self - The `ReadonlyRecord` to be mapped.
+ * @param f - A transformation function that will be applied to each of the values in the `ReadonlyRecord`.
+ *
+ * @example
+ * import { map } from "effect/ReadonlyRecord"
+ *
+ * const f = (n: number) => `-${n}`
+ *
+ * assert.deepStrictEqual(map({ a: 3, b: 5 }, f), { a: "-3", b: "-5" })
+ *
+ * const g = (n: number, key: string) => `${key.toUpperCase()}-${n}`
+ *
+ * assert.deepStrictEqual(map({ a: 3, b: 5 }, g), { a: "A-3", b: "B-5" })
+ *
+ * @since 2.0.0
+ */
+const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const out = {};
+  for (const key of Object.keys(self)) {
+    out[key] = f(self[key], key);
+  }
+  return out;
+});
+
+/**
+ * Transforms a `ReadonlyRecord` into a `Record` by applying the function `f` to each key and value in the original `ReadonlyRecord`.
+ * If the function returns `Some`, the key-value pair is included in the output `Record`.
+ *
+ * @param self - The input `ReadonlyRecord`.
+ * @param f - The transformation function.
+ *
+ * @example
+ * import { filterMap } from 'effect/ReadonlyRecord'
+ * import { some, none } from 'effect/Option'
+ *
+ * const x = { a: 1, b: 2, c: 3 }
+ * const f = (a: number, key: string) => a > 2 ? some(a * 2) : none()
+ * assert.deepStrictEqual(filterMap(x, f), { c: 6 })
+ *
+ * @since 2.0.0
+ */
+const filterMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const out = {};
+  for (const key of Object.keys(self)) {
+    const o = f(self[key], key);
+    if (Option_dist_effectOption.isSome(o)) {
+      out[key] = o.value;
+    }
+  }
+  return out;
+});
+
+/**
+ * Selects properties from a record whose values match the given predicate.
+ *
+ * @param self - The `ReadonlyRecord` to filter.
+ * @param predicate - A function that returns a `boolean` value to determine if the entry should be included in the new record.
+ *
+ * @example
+ * import { filter } from 'effect/ReadonlyRecord'
+ *
+ * const x = { a: 1, b: 2, c: 3, d: 4 }
+ * assert.deepStrictEqual(filter(x, (n) => n > 2), { c: 3, d: 4 })
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const filter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  const out = {};
+  for (const key of Object.keys(self)) {
+    if (predicate(self[key], key)) {
+      out[key] = self[key];
+    }
+  }
+  return out;
+});
+
+/**
+ * Given a `ReadonlyRecord` with `Option` values, returns a `Record` with only the `Some` values, with the same keys.
+ *
+ * @param self - A `ReadonlyRecord` with `Option` values.
+ *
+ * @example
+ * import { compact } from 'effect/ReadonlyRecord'
+ * import { some, none } from 'effect/Option'
+ *
+ * assert.deepStrictEqual(
+ *   compact({ a: some(1), b: none(), c: some(2) }),
+ *   { a: 1, c: 2 }
+ * )
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const compact = /*#__PURE__*/filterMap(Function_dist_effectFunction.identity);
+
+/**
+ * Partitions the elements of a `ReadonlyRecord` into two groups: those that match a predicate, and those that don't.
+ *
+ * @param self - The `ReadonlyRecord` to partition.
+ * @param f - The predicate function to apply to each element.
+ *
+ * @example
+ * import { partitionMap } from 'effect/ReadonlyRecord'
+ * import { left, right } from 'effect/Either'
+ *
+ * const x = { a: 1, b: 2, c: 3 }
+ * const f = (n: number) => (n % 2 === 0 ? right(n) : left(n))
+ * assert.deepStrictEqual(partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2}])
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const partitionMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
+  const left = {};
+  const right = {};
+  for (const key of Object.keys(self)) {
+    const e = f(self[key], key);
+    if (Either_dist_effectEither.isLeft(e)) {
+      left[key] = e.left;
+    } else {
+      right[key] = e.right;
+    }
+  }
+  return [left, right];
+});
+
+/**
+ * Partitions a `ReadonlyRecord` of `Either` values into two separate records,
+ * one with the `Left` values and one with the `Right` values.
+ *
+ * @param self - the `ReadonlyRecord` to partition.
+ *
+ * @example
+ * import { separate } from 'effect/ReadonlyRecord'
+ * import { left, right } from 'effect/Either'
+ *
+ * assert.deepStrictEqual(
+ *   separate({ a: left("e"), b: right(1) }),
+ *   [{ a: "e" }, { b: 1 }]
+ * )
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const separate = /*#__PURE__*/partitionMap(Function_dist_effectFunction.identity);
+
+/**
+ * Partitions a `ReadonlyRecord` into two separate `Record`s based on the result of a predicate function.
+ *
+ * @param self - The input `ReadonlyRecord` to partition.
+ * @param predicate - The partitioning function to determine the partitioning of each value of the `ReadonlyRecord`.
+ *
+ * @example
+ * import { partition } from 'effect/ReadonlyRecord'
+ *
+ * assert.deepStrictEqual(
+ *   partition({ a: 1, b: 3 }, (n) => n > 2),
+ *   [{ a: 1 }, { b: 3 }]
+ * )
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+const partition = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
+  const left = {};
+  const right = {};
+  for (const key of Object.keys(self)) {
+    if (predicate(self[key], key)) {
+      right[key] = self[key];
+    } else {
+      left[key] = self[key];
+    }
+  }
+  return [left, right];
+});
+
+exports.collect = collect;
+exports.compact = compact;
+exports.empty = empty;
+exports.filter = filter;
+exports.filterMap = filterMap;
+exports.fromEntries = fromEntries;
+exports.fromIterable = fromIterable;
+exports.get = get;
+exports.has = has;
+exports.isEmptyReadonlyRecord = isEmptyReadonlyRecord;
+exports.isEmptyRecord = isEmptyRecord;
+exports.map = map;
+exports.modifyOption = modifyOption;
+exports.partition = partition;
+exports.partitionMap = partitionMap;
+exports.pop = pop;
+exports.remove = remove;
+exports.replaceOption = replaceOption;
+exports.separate = separate;
+exports.size = size;
+exports.toArray = toArray;
+exports.toEntries = toEntries;