@monstermann/map 0.0.0

package/dist/Map/mapOrElse.d.ts

@@ -0,0 +1,67 @@
+import { MapMap, OrElse } from "./internals/types.js";
+
+//#region src/Map/mapOrElse.d.ts
+
+/**
+ * `Map.mapOrElse(map, key, transform, orElse)`
+ *
+ * Transforms the value at `key` in `map` using `transform`, calling `orElse` with the map if the key doesn't exist.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.mapOrElse(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "a",
+ *     (value) => value * 2,
+ *     () => null,
+ * ); // Map(2) { "a" => 2, "b" => 2 }
+ *
+ * Map.mapOrElse(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "c",
+ *     (value) => value * 2,
+ *     (map) => map.size,
+ * ); // 2
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.mapOrElse(
+ *         "a",
+ *         (value) => value * 2,
+ *         () => null,
+ *     ),
+ * ); // Map(2) { "a" => 2, "b" => 2 }
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.mapOrElse(
+ *         "c",
+ *         (value) => value * 2,
+ *         (map) => map.size,
+ *     ),
+ * ); // 2
+ * ```
+ */
+declare const mapOrElse: {
+  <K, V, U>(key: NoInfer<K>, transform: MapMap<K, V>, orElse: OrElse<K, V, U>): (target: Map<K, V>) => Map<K, V> | U;
+  <K, V, U>(key: NoInfer<K>, transform: MapMap<K, V>, orElse: OrElse<K, V, U>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V> | U;
+  <K, V, U>(target: Map<K, V>, key: NoInfer<K>, transform: MapMap<K, V>, orElse: OrElse<K, V, U>): Map<K, V> | U;
+  <K, V, U>(target: ReadonlyMap<K, V>, key: NoInfer<K>, transform: MapMap<K, V>, orElse: OrElse<K, V, U>): ReadonlyMap<K, V> | U;
+};
+//#endregion
+export { mapOrElse };

package/dist/Map/mapOrElse.js

@@ -0,0 +1,71 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneMap } from "@monstermann/remmi";
+
+//#region src/Map/mapOrElse.ts
+/**
+* `Map.mapOrElse(map, key, transform, orElse)`
+*
+* Transforms the value at `key` in `map` using `transform`, calling `orElse` with the map if the key doesn't exist.
+*
+* ## Example
+*
+* ```ts
+* Map.mapOrElse(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "a",
+*     (value) => value * 2,
+*     () => null,
+* ); // Map(2) { "a" => 2, "b" => 2 }
+*
+* Map.mapOrElse(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "c",
+*     (value) => value * 2,
+*     (map) => map.size,
+* ); // 2
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.mapOrElse(
+*         "a",
+*         (value) => value * 2,
+*         () => null,
+*     ),
+* ); // Map(2) { "a" => 2, "b" => 2 }
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.mapOrElse(
+*         "c",
+*         (value) => value * 2,
+*         (map) => map.size,
+*     ),
+* ); // 2
+* ```
+*/
+const mapOrElse = dfdlT((target, key, transform, orElse) => {
+	if (!target.has(key)) return orElse(target);
+	const prev = target.get(key);
+	const next = transform(prev, key, target);
+	if (prev === next) return target;
+	const result = cloneMap(target);
+	result.set(key, next);
+	return result;
+}, 4);
+
+//#endregion
+export { mapOrElse };

package/dist/Map/mapOrThrow.d.ts

@@ -0,0 +1,57 @@
+import { MapMap } from "./internals/types.js";
+
+//#region src/Map/mapOrThrow.d.ts
+
+/**
+ * `Map.mapOrThrow(map, key, transform)`
+ *
+ * Transforms the value at `key` in `map` using `transform`, throwing an error if the key doesn't exist.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.mapOrThrow(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "a",
+ *     (value) => value * 2,
+ * ); // Map(2) { "a" => 2, "b" => 2 }
+ *
+ * Map.mapOrThrow(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "c",
+ *     (value) => value * 2,
+ * ); // throws FnError
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.mapOrThrow("a", (value) => value * 2),
+ * ); // Map(2) { "a" => 2, "b" => 2 }
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.mapOrThrow("c", (value) => value * 2),
+ * ); // throws FnError
+ * ```
+ */
+declare const mapOrThrow: {
+  <K, V>(key: NoInfer<K>, transform: MapMap<K, V>): (target: Map<K, V>) => Map<K, V>;
+  <K, V>(key: NoInfer<K>, transform: MapMap<K, V>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  <K, V>(target: Map<K, V>, key: NoInfer<K>, transform: MapMap<K, V>): Map<K, V>;
+  <K, V>(target: ReadonlyMap<K, V>, key: NoInfer<K>, transform: MapMap<K, V>): ReadonlyMap<K, V>;
+};
+//#endregion
+export { mapOrThrow };

package/dist/Map/mapOrThrow.js

@@ -0,0 +1,61 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneMap } from "@monstermann/remmi";
+
+//#region src/Map/mapOrThrow.ts
+/**
+* `Map.mapOrThrow(map, key, transform)`
+*
+* Transforms the value at `key` in `map` using `transform`, throwing an error if the key doesn't exist.
+*
+* ## Example
+*
+* ```ts
+* Map.mapOrThrow(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "a",
+*     (value) => value * 2,
+* ); // Map(2) { "a" => 2, "b" => 2 }
+*
+* Map.mapOrThrow(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "c",
+*     (value) => value * 2,
+* ); // throws FnError
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.mapOrThrow("a", (value) => value * 2),
+* ); // Map(2) { "a" => 2, "b" => 2 }
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.mapOrThrow("c", (value) => value * 2),
+* ); // throws FnError
+* ```
+*/
+const mapOrThrow = dfdlT((target, key, transform) => {
+	if (!target.has(key)) throw new Error("Map.mapOrThrow: Key does not exist.");
+	const prev = target.get(key);
+	const next = transform(prev, key, target);
+	if (prev === next) return target;
+	const result = cloneMap(target);
+	result.set(key, next);
+	return result;
+}, 3);
+
+//#endregion
+export { mapOrThrow };

package/dist/Map/reject.d.ts

@@ -0,0 +1,45 @@
+import { MapGuard, MapPredicate } from "./internals/types.js";
+
+//#region src/Map/reject.d.ts
+
+/**
+ * `Map.reject(map, by)`
+ *
+ * Rejects entries from `map` where `by` returns true for the value.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.reject(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     (value) => value > 1,
+ * ); // Map(1) { "a" => 1 }
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.reject((value) => value > 1),
+ * ); // Map(1) { "a" => 1 }
+ * ```
+ */
+declare const reject: {
+  <K, V, U extends V>(by: MapGuard<K, V, U>): (target: Map<K, V>) => Map<K, Exclude<V, U>>;
+  <K, V, U extends V>(by: MapGuard<K, V, U>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, Exclude<V, U>>;
+  <K, V>(by: MapPredicate<K, V>): (target: Map<K, V>) => Map<K, V>;
+  <K, V>(by: MapPredicate<K, V>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  <K, V, U extends V>(target: Map<K, V>, by: MapGuard<K, V, U>): Map<K, Exclude<V, U>>;
+  <K, V, U extends V>(target: ReadonlyMap<K, V>, by: MapGuard<K, V, U>): ReadonlyMap<K, Exclude<V, U>>;
+  <K, V>(target: Map<K, V>, by: MapPredicate<K, V>): Map<K, V>;
+  <K, V>(target: ReadonlyMap<K, V>, by: MapPredicate<K, V>): ReadonlyMap<K, V>;
+};
+//#endregion
+export { reject };

package/dist/Map/reject.js

@@ -0,0 +1,44 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneMap } from "@monstermann/remmi";
+
+//#region src/Map/reject.ts
+/**
+* `Map.reject(map, by)`
+*
+* Rejects entries from `map` where `by` returns true for the value.
+*
+* ## Example
+*
+* ```ts
+* Map.reject(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     (value) => value > 1,
+* ); // Map(1) { "a" => 1 }
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     Map.reject((value) => value > 1),
+* ); // Map(1) { "a" => 1 }
+* ```
+*/
+const reject = dfdlT((target, by) => {
+	let result;
+	for (const [key, value] of target) if (by(value, key, target)) {
+		result ??= cloneMap(target);
+		result.delete(key);
+	}
+	return result ?? target;
+}, 2);
+
+//#endregion
+export { reject };

package/dist/Map/remove.d.ts

@@ -0,0 +1,52 @@
+//#region src/Map/remove.d.ts
+/**
+ * `Map.remove(map, key)`
+ *
+ * Removes the entry with the specified `key` from `map`, returning a new map.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.remove(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "a",
+ * ); // Map(1) { "b" => 2 }
+ *
+ * Map.remove(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "c",
+ * ); // Map(2) { "a" => 1, "b" => 2 }
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.remove("a"),
+ * ); // Map(1) { "b" => 2 }
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.remove("c"),
+ * ); // Map(2) { "a" => 1, "b" => 2 }
+ * ```
+ */
+declare const remove: {
+  <K, V>(key: NoInfer<K>): (target: Map<K, V>) => Map<K, V>;
+  <K, V>(key: NoInfer<K>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  <K, V>(target: Map<K, V>, key: NoInfer<K>): Map<K, V>;
+  <K, V>(target: ReadonlyMap<K, V>, key: NoInfer<K>): ReadonlyMap<K, V>;
+};
+//#endregion
+export { remove };

package/dist/Map/remove.js

@@ -0,0 +1,56 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneMap } from "@monstermann/remmi";
+
+//#region src/Map/remove.ts
+/**
+* `Map.remove(map, key)`
+*
+* Removes the entry with the specified `key` from `map`, returning a new map.
+*
+* ## Example
+*
+* ```ts
+* Map.remove(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "a",
+* ); // Map(1) { "b" => 2 }
+*
+* Map.remove(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "c",
+* ); // Map(2) { "a" => 1, "b" => 2 }
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.remove("a"),
+* ); // Map(1) { "b" => 2 }
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.remove("c"),
+* ); // Map(2) { "a" => 1, "b" => 2 }
+* ```
+*/
+const remove = dfdlT((target, key) => {
+	if (!target.has(key)) return target;
+	target = cloneMap(target);
+	target.delete(key);
+	return target;
+}, 2);
+
+//#endregion
+export { remove };

package/dist/Map/removeAll.d.ts

@@ -0,0 +1,56 @@
+//#region src/Map/removeAll.d.ts
+/**
+ * `Map.removeAll(map, keys)`
+ *
+ * Removes all entries with the specified `keys` from `map`, returning a new map. This function supports iterables.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.removeAll(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     ["a", "c"],
+ * ); // Map(1) { "b" => 2 }
+ *
+ * Map.removeAll(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     ["d", "e"],
+ * ); // Map(3) { "a" => 1, "b" => 2, "c" => 3 }
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.removeAll(["a", "c"]),
+ * ); // Map(1) { "b" => 2 }
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.removeAll(["d", "e"]),
+ * ); // Map(3) { "a" => 1, "b" => 2, "c" => 3 }
+ * ```
+ */
+declare const removeAll: {
+  <K, V>(keys: Iterable<NoInfer<K>>): (target: Map<K, V>) => Map<K, V>;
+  <K, V>(keys: Iterable<NoInfer<K>>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  <K, V>(target: Map<K, V>, keys: Iterable<NoInfer<K>>): Map<K, V>;
+  <K, V>(target: ReadonlyMap<K, V>, keys: Iterable<NoInfer<K>>): ReadonlyMap<K, V>;
+};
+//#endregion
+export { removeAll };

package/dist/Map/removeAll.js

@@ -0,0 +1,63 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneMap } from "@monstermann/remmi";
+
+//#region src/Map/removeAll.ts
+/**
+* `Map.removeAll(map, keys)`
+*
+* Removes all entries with the specified `keys` from `map`, returning a new map. This function supports iterables.
+*
+* ## Example
+*
+* ```ts
+* Map.removeAll(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     ["a", "c"],
+* ); // Map(1) { "b" => 2 }
+*
+* Map.removeAll(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     ["d", "e"],
+* ); // Map(3) { "a" => 1, "b" => 2, "c" => 3 }
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     Map.removeAll(["a", "c"]),
+* ); // Map(1) { "b" => 2 }
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     Map.removeAll(["d", "e"]),
+* ); // Map(3) { "a" => 1, "b" => 2, "c" => 3 }
+* ```
+*/
+const removeAll = dfdlT((target, keys) => {
+	let result;
+	for (const key of keys) {
+		if (!target.has(key)) continue;
+		result ??= cloneMap(target);
+		result.delete(key);
+	}
+	return result ?? target;
+}, 2);
+
+//#endregion
+export { removeAll };

package/dist/Map/removeOr.d.ts

@@ -0,0 +1,52 @@
+//#region src/Map/removeOr.d.ts
+/**
+ * `Map.removeOr(map, key, or)`
+ *
+ * Removes the entry with the specified `key` from `map`, returning `or` if the key doesn't exist.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.removeOr(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "a",
+ *     null,
+ * ); // Map(1) { "b" => 2 }
+ *
+ * Map.removeOr(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "c",
+ *     null,
+ * ); // null
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.removeOr("a", null),
+ * ); // Map(1) { "b" => 2 }
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.removeOr("c", null),
+ * ); // null
+ * ```
+ */
+declare const removeOr: {
+  <K, V, U>(key: NoInfer<K>, or: U): (target: ReadonlyMap<K, V>) => Map<K, V> | U;
+  <K, V, U>(target: ReadonlyMap<K, V>, key: NoInfer<K>, or: U): Map<K, V> | U;
+};
+//#endregion
+export { removeOr };

package/dist/Map/removeOr.js

@@ -0,0 +1,58 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneMap } from "@monstermann/remmi";
+
+//#region src/Map/removeOr.ts
+/**
+* `Map.removeOr(map, key, or)`
+*
+* Removes the entry with the specified `key` from `map`, returning `or` if the key doesn't exist.
+*
+* ## Example
+*
+* ```ts
+* Map.removeOr(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "a",
+*     null,
+* ); // Map(1) { "b" => 2 }
+*
+* Map.removeOr(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "c",
+*     null,
+* ); // null
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.removeOr("a", null),
+* ); // Map(1) { "b" => 2 }
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.removeOr("c", null),
+* ); // null
+* ```
+*/
+const removeOr = dfdlT((target, key, or) => {
+	if (!target.has(key)) return or;
+	const result = cloneMap(target);
+	result.delete(key);
+	return result;
+}, 3);
+
+//#endregion
+export { removeOr };