@monstermann/map 0.1.2 → 0.2.0

package/dist/Map/findOr.d.mts

@@ -0,0 +1,56 @@
+//#region src/Map/findOr.d.ts
+/**
+ * # findOr
+ *
+ * ```ts
+ * function Map.findOr<K, V, O>(
+ *     target: ReadonlyMap<K, V>,
+ *     predicate: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => boolean,
+ *     or: O,
+ * ): V | O
+ * ```
+ *
+ * Returns the first value in the map that satisfies the provided `predicate` function, or `or` if no value is found.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Map } from "@monstermann/map";
+ *
+ * Map.findOr(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     (value) => value > 10,
+ *     0,
+ * ); // 0
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Map } from "@monstermann/map";
+ *
+ * pipe(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.findOr((value) => value > 10, 0),
+ * ); // 0
+ * ```
+ *
+ */
+declare const findOr: {
+  <K, V, U extends V, O>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U, or: O): (target: ReadonlyMap<K, V>) => U | O;
+  <K, V, O>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean, or: O): (target: ReadonlyMap<K, V>) => V | O;
+  <K, V, U extends V, O>(target: ReadonlyMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U, or: O): U | O;
+  <K, V, O>(target: ReadonlyMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean, or: O): V | O;
+};
+//#endregion
+export { findOr };

package/dist/Map/findOr.mjs

@@ -0,0 +1,57 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/findOr.ts
+/**
+* # findOr
+*
+* ```ts
+* function Map.findOr<K, V, O>(
+*     target: ReadonlyMap<K, V>,
+*     predicate: (
+*         value: NoInfer<V>,
+*         key: NoInfer<K>,
+*         target: ReadonlyMap<K, V>,
+*     ) => boolean,
+*     or: O,
+* ): V | O
+* ```
+*
+* Returns the first value in the map that satisfies the provided `predicate` function, or `or` if no value is found.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Map } from "@monstermann/map";
+*
+* Map.findOr(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     (value) => value > 10,
+*     0,
+* ); // 0
+* ```
+*
+* ```ts [data-last]
+* import { Map } from "@monstermann/map";
+*
+* pipe(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     Map.findOr((value) => value > 10, 0),
+* ); // 0
+* ```
+*
+*/
+const findOr = dfdlT((target, predicate, or) => {
+	for (const [key, value] of target) if (predicate(value, key, target)) return value;
+	return or;
+}, 3);
+
+//#endregion
+export { findOr };

package/dist/Map/findOrElse.d.mts

@@ -0,0 +1,59 @@
+//#region src/Map/findOrElse.d.ts
+/**
+ * # findOrElse
+ *
+ * ```ts
+ * function Map.findOrElse<K, V, O>(
+ *     target: ReadonlyMap<K, V>,
+ *     predicate: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => boolean,
+ *     orElse: (target: ReadonlyMap<K, V>) => O,
+ * ): V | O
+ * ```
+ *
+ * Returns the first value in the map that satisfies the provided `predicate` function, or the result of calling `orElse` with the map if no value is found.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Map } from "@monstermann/map";
+ *
+ * Map.findOrElse(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     (value) => value > 10,
+ *     (map) => map.size,
+ * ); // 3
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Map } from "@monstermann/map";
+ *
+ * pipe(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.findOrElse(
+ *         (value) => value > 10,
+ *         (map) => map.size,
+ *     ),
+ * ); // 3
+ * ```
+ *
+ */
+declare const findOrElse: {
+  <K, V, U extends V, O>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U, orElse: (target: ReadonlyMap<K, Exclude<V, U>>) => O): (target: ReadonlyMap<K, V>) => U | O;
+  <K, V, O>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean, orElse: (target: ReadonlyMap<K, V>) => O): (target: ReadonlyMap<K, V>) => V | O;
+  <K, V, U extends V, O>(target: ReadonlyMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U, orElse: (target: ReadonlyMap<K, Exclude<V, U>>) => O): U | O;
+  <K, V, O>(target: ReadonlyMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean, orElse: (target: ReadonlyMap<K, V>) => O): V | O;
+};
+//#endregion
+export { findOrElse };

package/dist/Map/findOrElse.mjs

@@ -0,0 +1,60 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/findOrElse.ts
+/**
+* # findOrElse
+*
+* ```ts
+* function Map.findOrElse<K, V, O>(
+*     target: ReadonlyMap<K, V>,
+*     predicate: (
+*         value: NoInfer<V>,
+*         key: NoInfer<K>,
+*         target: ReadonlyMap<K, V>,
+*     ) => boolean,
+*     orElse: (target: ReadonlyMap<K, V>) => O,
+* ): V | O
+* ```
+*
+* Returns the first value in the map that satisfies the provided `predicate` function, or the result of calling `orElse` with the map if no value is found.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Map } from "@monstermann/map";
+*
+* Map.findOrElse(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     (value) => value > 10,
+*     (map) => map.size,
+* ); // 3
+* ```
+*
+* ```ts [data-last]
+* import { Map } from "@monstermann/map";
+*
+* pipe(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     Map.findOrElse(
+*         (value) => value > 10,
+*         (map) => map.size,
+*     ),
+* ); // 3
+* ```
+*
+*/
+const findOrElse = dfdlT((target, predicate, orElse) => {
+	for (const [key, value] of target) if (predicate(value, key, target)) return value;
+	return orElse(target);
+}, 3);
+
+//#endregion
+export { findOrElse };

package/dist/Map/findOrThrow.d.mts

@@ -0,0 +1,54 @@
+//#region src/Map/findOrThrow.d.ts
+/**
+ * # findOrThrow
+ *
+ * ```ts
+ * function Map.findOrThrow<K, V>(
+ *     target: ReadonlyMap<K, V>,
+ *     predicate: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => boolean,
+ * ): V
+ * ```
+ *
+ * Returns the first value in the map that satisfies the provided `predicate` function, or throws an error if no value is found.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Map } from "@monstermann/map";
+ *
+ * Map.findOrThrow(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     (value) => value > 2,
+ * ); // 3
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Map } from "@monstermann/map";
+ *
+ * pipe(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.findOrThrow((value) => value > 2),
+ * ); // 3
+ * ```
+ *
+ */
+declare const findOrThrow: {
+  <K, V, U extends V>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U): (target: ReadonlyMap<K, V>) => U;
+  <K, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): (target: ReadonlyMap<K, V>) => V;
+  <K, V, U extends V>(target: ReadonlyMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U): U;
+  <K, V>(target: ReadonlyMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): V;
+};
+//#endregion
+export { findOrThrow };

package/dist/Map/findOrThrow.mjs

@@ -0,0 +1,55 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/findOrThrow.ts
+/**
+* # findOrThrow
+*
+* ```ts
+* function Map.findOrThrow<K, V>(
+*     target: ReadonlyMap<K, V>,
+*     predicate: (
+*         value: NoInfer<V>,
+*         key: NoInfer<K>,
+*         target: ReadonlyMap<K, V>,
+*     ) => boolean,
+* ): V
+* ```
+*
+* Returns the first value in the map that satisfies the provided `predicate` function, or throws an error if no value is found.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Map } from "@monstermann/map";
+*
+* Map.findOrThrow(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     (value) => value > 2,
+* ); // 3
+* ```
+*
+* ```ts [data-last]
+* import { Map } from "@monstermann/map";
+*
+* pipe(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     Map.findOrThrow((value) => value > 2),
+* ); // 3
+* ```
+*
+*/
+const findOrThrow = dfdlT((target, predicate) => {
+	for (const [key, value] of target) if (predicate(value, key, target)) return value;
+	throw new Error("Map.findOrThrow: Value not found.");
+}, 2);
+
+//#endregion
+export { findOrThrow };

package/dist/Map/findRemove.d.mts

@@ -0,0 +1,54 @@
+//#region src/Map/findRemove.d.ts
+/**
+ * # findRemove
+ *
+ * ```ts
+ * function Map.findRemove<K, V>(
+ *     target: ReadonlyMap<K, V>,
+ *     predicate: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => boolean,
+ * ): ReadonlyMap<K, V>
+ * ```
+ *
+ * Finds the first entry in the map that satisfies the provided `predicate` function and removes it, returning a new map without the removed entry.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Map } from "@monstermann/map";
+ *
+ * Map.findRemove(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     (value) => value > 1,
+ * ); // Map(2) { "a" => 1, "c" => 3 }
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Map } from "@monstermann/map";
+ *
+ * pipe(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.findRemove((value) => value > 1),
+ * ); // Map(2) { "a" => 1, "c" => 3 }
+ * ```
+ *
+ */
+declare const findRemove: {
+  <K, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): (target: Map<K, V>) => Map<K, V>;
+  <K, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  <K, V>(target: Map<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): Map<K, V>;
+  <K, V>(target: ReadonlyMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): ReadonlyMap<K, V>;
+};
+//#endregion
+export { findRemove };

package/dist/Map/findRemove.mjs

@@ -0,0 +1,60 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneMap } from "@monstermann/remmi";
+
+//#region src/Map/findRemove.ts
+/**
+* # findRemove
+*
+* ```ts
+* function Map.findRemove<K, V>(
+*     target: ReadonlyMap<K, V>,
+*     predicate: (
+*         value: NoInfer<V>,
+*         key: NoInfer<K>,
+*         target: ReadonlyMap<K, V>,
+*     ) => boolean,
+* ): ReadonlyMap<K, V>
+* ```
+*
+* Finds the first entry in the map that satisfies the provided `predicate` function and removes it, returning a new map without the removed entry.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Map } from "@monstermann/map";
+*
+* Map.findRemove(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     (value) => value > 1,
+* ); // Map(2) { "a" => 1, "c" => 3 }
+* ```
+*
+* ```ts [data-last]
+* import { Map } from "@monstermann/map";
+*
+* pipe(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     Map.findRemove((value) => value > 1),
+* ); // Map(2) { "a" => 1, "c" => 3 }
+* ```
+*
+*/
+const findRemove = dfdlT((target, predicate) => {
+	for (const [key, value] of target) if (predicate(value, key, target)) {
+		const result = cloneMap(target);
+		result.delete(key);
+		return result;
+	}
+	return target;
+}, 2);
+
+//#endregion
+export { findRemove };

package/dist/Map/findRemoveOr.d.mts

@@ -0,0 +1,56 @@
+//#region src/Map/findRemoveOr.d.ts
+/**
+ * # findRemoveOr
+ *
+ * ```ts
+ * function Map.findRemoveOr<K, V, O>(
+ *     target: ReadonlyMap<K, V>,
+ *     predicate: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => boolean,
+ *     or: O,
+ * ): ReadonlyMap<K, V> | O
+ * ```
+ *
+ * Finds the first entry in the map that satisfies the provided `predicate` function and removes it, returning a new map without the removed entry, or `or` if no entry is found.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Map } from "@monstermann/map";
+ *
+ * Map.findRemoveOr(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     (value) => value > 10,
+ *     new Map(),
+ * ); // Map(0) {}
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Map } from "@monstermann/map";
+ *
+ * pipe(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.findRemoveOr((value) => value > 10, new Map()),
+ * ); // Map(0) {}
+ * ```
+ *
+ */
+declare const findRemoveOr: {
+  <K, V, O>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean, or: O): (target: Map<K, V>) => Map<K, V> | O;
+  <K, V, O>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean, or: O): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V> | O;
+  <K, V, O>(target: Map<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean, or: O): Map<K, V> | O;
+  <K, V, O>(target: ReadonlyMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean, or: O): ReadonlyMap<K, V> | O;
+};
+//#endregion
+export { findRemoveOr };

package/dist/Map/findRemoveOr.mjs

@@ -0,0 +1,62 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneMap } from "@monstermann/remmi";
+
+//#region src/Map/findRemoveOr.ts
+/**
+* # findRemoveOr
+*
+* ```ts
+* function Map.findRemoveOr<K, V, O>(
+*     target: ReadonlyMap<K, V>,
+*     predicate: (
+*         value: NoInfer<V>,
+*         key: NoInfer<K>,
+*         target: ReadonlyMap<K, V>,
+*     ) => boolean,
+*     or: O,
+* ): ReadonlyMap<K, V> | O
+* ```
+*
+* Finds the first entry in the map that satisfies the provided `predicate` function and removes it, returning a new map without the removed entry, or `or` if no entry is found.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Map } from "@monstermann/map";
+*
+* Map.findRemoveOr(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     (value) => value > 10,
+*     new Map(),
+* ); // Map(0) {}
+* ```
+*
+* ```ts [data-last]
+* import { Map } from "@monstermann/map";
+*
+* pipe(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     Map.findRemoveOr((value) => value > 10, new Map()),
+* ); // Map(0) {}
+* ```
+*
+*/
+const findRemoveOr = dfdlT((target, predicate, or) => {
+	for (const [key, value] of target) if (predicate(value, key, target)) {
+		const result = cloneMap(target);
+		result.delete(key);
+		return result;
+	}
+	return or;
+}, 3);
+
+//#endregion
+export { findRemoveOr };

package/dist/Map/findRemoveOrElse.d.mts

@@ -0,0 +1,59 @@
+//#region src/Map/findRemoveOrElse.d.ts
+/**
+ * # findRemoveOrElse
+ *
+ * ```ts
+ * function Map.findRemoveOrElse<K, V, O>(
+ *     target: ReadonlyMap<K, V>,
+ *     predicate: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => boolean,
+ *     orElse: (target: ReadonlyMap<K, V>) => O,
+ * ): ReadonlyMap<K, V> | O
+ * ```
+ *
+ * Finds the first entry in the map that satisfies the provided `predicate` function and removes it, returning a new map without the removed entry, or the result of calling `orElse` with the map if no entry is found.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Map } from "@monstermann/map";
+ *
+ * Map.findRemoveOrElse(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     (value) => value > 10,
+ *     (map) => map.size,
+ * ); // 3
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Map } from "@monstermann/map";
+ *
+ * pipe(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.findRemoveOrElse(
+ *         (value) => value > 10,
+ *         (map) => map.size,
+ *     ),
+ * ); // 3
+ * ```
+ *
+ */
+declare const findRemoveOrElse: {
+  <K, V, O>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean, orElse: (target: ReadonlyMap<K, V>) => O): (target: Map<K, V>) => Map<K, V> | O;
+  <K, V, O>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean, orElse: (target: ReadonlyMap<K, V>) => O): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V> | O;
+  <K, V, O>(target: Map<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean, orElse: (target: ReadonlyMap<K, V>) => O): Map<K, V> | O;
+  <K, V, O>(target: ReadonlyMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean, orElse: (target: ReadonlyMap<K, V>) => O): ReadonlyMap<K, V> | O;
+};
+//#endregion
+export { findRemoveOrElse };