@monstermann/map 0.0.0

package/dist/Map/index.js

@@ -0,0 +1,61 @@
+import { clone } from "./clone.js";
+import { filter } from "./filter.js";
+import { compact } from "./compact.js";
+import { forEach } from "./forEach.js";
+import { get } from "./get.js";
+import { getOr } from "./getOr.js";
+import { getOrElse } from "./getOrElse.js";
+import { getOrThrow } from "./getOrThrow.js";
+import { has } from "./has.js";
+import { hasAll } from "./hasAll.js";
+import { hasAny } from "./hasAny.js";
+import { hasNone } from "./hasNone.js";
+import { isEmpty } from "./isEmpty.js";
+import { isMap } from "./isMap.js";
+import { isShallowEqual } from "./isShallowEqual.js";
+import { map } from "./map.js";
+import { mapEach } from "./mapEach.js";
+import { mapOr } from "./mapOr.js";
+import { mapOrElse } from "./mapOrElse.js";
+import { mapOrThrow } from "./mapOrThrow.js";
+import { reject } from "./reject.js";
+import { remove } from "./remove.js";
+import { removeAll } from "./removeAll.js";
+import { removeOr } from "./removeOr.js";
+import { removeOrElse } from "./removeOrElse.js";
+import { removeOrThrow } from "./removeOrThrow.js";
+import { set } from "./set.js";
+
+//#region src/Map/index.js
+const Map = {
+	clone,
+	compact,
+	filter,
+	forEach,
+	get,
+	getOr,
+	getOrElse,
+	getOrThrow,
+	has,
+	hasAll,
+	hasAny,
+	hasNone,
+	isEmpty,
+	isMap,
+	isShallowEqual,
+	map,
+	mapEach,
+	mapOr,
+	mapOrElse,
+	mapOrThrow,
+	reject,
+	remove,
+	removeAll,
+	removeOr,
+	removeOrElse,
+	removeOrThrow,
+	set
+};
+
+//#endregion
+export { Map };

package/dist/Map/internals/types.d.ts

@@ -0,0 +1,14 @@
+//#region src/Map/internals/types.d.ts
+type NonNil<T> = Exclude<T, null | undefined>;
+interface MapGuard<K, V, U extends V> {
+  (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>): value is U;
+}
+interface MapMap<K, V, U = V> {
+  (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>): U;
+}
+type MapPredicate<K, V> = MapMap<K, V, boolean>;
+interface OrElse<K, V, U> {
+  (target: ReadonlyMap<K, V>): U;
+}
+//#endregion
+export { MapGuard, MapMap, MapPredicate, NonNil, OrElse };

package/dist/Map/isEmpty.d.ts

@@ -0,0 +1,24 @@
+//#region src/Map/isEmpty.d.ts
+/**
+ * `Map.isEmpty(map)`
+ *
+ * Checks if `map` is empty (has no entries).
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.isEmpty(Map.create()); // true
+ * Map.isEmpty(Map.create([["a", 1]])); // false
+ * ```
+ *
+ * ```ts
+ * pipe(Map.create(), Map.isEmpty()); // true
+ * pipe(Map.create([["a", 1]]), Map.isEmpty()); // false
+ * ```
+ */
+declare const isEmpty: {
+  (): <T, U>(target: ReadonlyMap<T, U>) => boolean;
+  <T, U>(target: ReadonlyMap<T, U>): boolean;
+};
+//#endregion
+export { isEmpty };

package/dist/Map/isEmpty.js

@@ -0,0 +1,26 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/isEmpty.ts
+/**
+* `Map.isEmpty(map)`
+*
+* Checks if `map` is empty (has no entries).
+*
+* ## Example
+*
+* ```ts
+* Map.isEmpty(Map.create()); // true
+* Map.isEmpty(Map.create([["a", 1]])); // false
+* ```
+*
+* ```ts
+* pipe(Map.create(), Map.isEmpty()); // true
+* pipe(Map.create([["a", 1]]), Map.isEmpty()); // false
+* ```
+*/
+const isEmpty = dfdlT((target) => {
+	return target.size === 0;
+}, 1);
+
+//#endregion
+export { isEmpty };

package/dist/Map/isMap.d.ts

@@ -0,0 +1,26 @@
+//#region src/Map/isMap.d.ts
+/**
+ * `Map.isMap(target)`
+ *
+ * Checks if `target` is a Map instance.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.isMap(Map.create()); // true
+ * Map.isMap({}); // false
+ * Map.isMap([]); // false
+ * ```
+ *
+ * ```ts
+ * pipe(Map.create(), Map.isMap()); // true
+ * pipe({}, Map.isMap()); // false
+ * pipe([], Map.isMap()); // false
+ * ```
+ */
+declare const isMap: {
+  (): (target: unknown) => target is Map<unknown, unknown>;
+  (target: unknown): target is Map<unknown, unknown>;
+};
+//#endregion
+export { isMap };

package/dist/Map/isMap.js

@@ -0,0 +1,28 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/isMap.ts
+/**
+* `Map.isMap(target)`
+*
+* Checks if `target` is a Map instance.
+*
+* ## Example
+*
+* ```ts
+* Map.isMap(Map.create()); // true
+* Map.isMap({}); // false
+* Map.isMap([]); // false
+* ```
+*
+* ```ts
+* pipe(Map.create(), Map.isMap()); // true
+* pipe({}, Map.isMap()); // false
+* pipe([], Map.isMap()); // false
+* ```
+*/
+const isMap = dfdlT((target) => {
+	return target instanceof Map;
+}, 1);
+
+//#endregion
+export { isMap };

package/dist/Map/isShallowEqual.d.ts

@@ -0,0 +1,66 @@
+//#region src/Map/isShallowEqual.d.ts
+/**
+ * `Map.isShallowEqual(map, source)`
+ *
+ * Checks if `map` is shallow equal to `source` by comparing their keys and values using strict equality.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.isShallowEqual(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ * ); // true
+ *
+ * Map.isShallowEqual(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 3],
+ *     ]),
+ * ); // false
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.isShallowEqual(
+ *         Map.create([
+ *             ["a", 1],
+ *             ["b", 2],
+ *         ]),
+ *     ),
+ * ); // true
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.isShallowEqual(
+ *         Map.create([
+ *             ["a", 1],
+ *             ["b", 3],
+ *         ]),
+ *     ),
+ * ); // false
+ * ```
+ */
+declare const isShallowEqual: {
+  <K, V>(source: ReadonlyMap<NoInfer<K>, NoInfer<V>>): (target: ReadonlyMap<K, V>) => boolean;
+  <K, V>(target: ReadonlyMap<K, V>, source: ReadonlyMap<NoInfer<K>, NoInfer<V>>): boolean;
+};
+//#endregion
+export { isShallowEqual };

package/dist/Map/isShallowEqual.js

@@ -0,0 +1,80 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/isShallowEqual.ts
+/**
+* `Map.isShallowEqual(map, source)`
+*
+* Checks if `map` is shallow equal to `source` by comparing their keys and values using strict equality.
+*
+* ## Example
+*
+* ```ts
+* Map.isShallowEqual(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+* ); // true
+*
+* Map.isShallowEqual(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.create([
+*         ["a", 1],
+*         ["b", 3],
+*     ]),
+* ); // false
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.isShallowEqual(
+*         Map.create([
+*             ["a", 1],
+*             ["b", 2],
+*         ]),
+*     ),
+* ); // true
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.isShallowEqual(
+*         Map.create([
+*             ["a", 1],
+*             ["b", 3],
+*         ]),
+*     ),
+* ); // false
+* ```
+*/
+const isShallowEqual = dfdlT((target, source) => {
+	if (target.size !== source.size) return false;
+	const seen = /* @__PURE__ */ new Set();
+	for (const k of target.keys()) {
+		seen.add(k);
+		if (!source.has(k)) return false;
+		if (target.get(k) !== source.get(k)) return false;
+	}
+	for (const k of source.keys()) {
+		if (seen.has(k)) continue;
+		if (!target.has(k)) return false;
+		if (target.get(k) !== source.get(k)) return false;
+	}
+	return true;
+}, 2);
+
+//#endregion
+export { isShallowEqual };

package/dist/Map/map.d.ts

@@ -0,0 +1,55 @@
+import { MapMap } from "./internals/types.js";
+
+//#region src/Map/map.d.ts
+
+/**
+ * `Map.map(map, key, transform)`
+ *
+ * Transforms the value at `key` in `map` using `transform`, returning a new map if the value changes.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.map(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "a",
+ *     (value) => value * 2,
+ * ); // Map(2) { "a" => 2, "b" => 2 }
+ *
+ * Map.map(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "c",
+ *     (value) => value * 2,
+ * ); // Map(2) { "a" => 1, "b" => 2 }
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.map("a", (value) => value * 2),
+ * ); // Map(2) { "a" => 2, "b" => 2 }
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.map("c", (value) => value * 2),
+ */
+declare const map: {
+  <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 { map };

package/dist/Map/map.js

@@ -0,0 +1,59 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneMap } from "@monstermann/remmi";
+
+//#region src/Map/map.ts
+/**
+* `Map.map(map, key, transform)`
+*
+* Transforms the value at `key` in `map` using `transform`, returning a new map if the value changes.
+*
+* ## Example
+*
+* ```ts
+* Map.map(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "a",
+*     (value) => value * 2,
+* ); // Map(2) { "a" => 2, "b" => 2 }
+*
+* Map.map(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "c",
+*     (value) => value * 2,
+* ); // Map(2) { "a" => 1, "b" => 2 }
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.map("a", (value) => value * 2),
+* ); // Map(2) { "a" => 2, "b" => 2 }
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.map("c", (value) => value * 2),
+*/
+const map = dfdlT((target, key, transform) => {
+	if (!target.has(key)) return 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;
+}, 3);
+
+//#endregion
+export { map };

package/dist/Map/mapEach.d.ts

@@ -0,0 +1,39 @@
+import { MapMap } from "./internals/types.js";
+
+//#region src/Map/mapEach.d.ts
+
+/**
+ * `Map.mapEach(map, fn)`
+ *
+ * Maps each value in `map` using `fn`, returning a new map with the transformed values.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.mapEach(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     (value, key) => value * 2,
+ * ); // Map(2) { "a" => 2, "b" => 4 }
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.mapEach((value, key) => value * 2),
+ * ); // Map(2) { "a" => 2, "b" => 4 }
+ * ```
+ */
+declare const mapEach: {
+  <K, V, U>(fn: MapMap<K, V, U>): (target: Map<K, V>) => Map<K, U>;
+  <K, V, U>(fn: MapMap<K, V, U>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, U>;
+  <K, V, U>(target: Map<K, V>, fn: MapMap<K, V, U>): Map<K, U>;
+  <K, V, U>(target: ReadonlyMap<K, V>, fn: MapMap<K, V, U>): ReadonlyMap<K, U>;
+};
+//#endregion
+export { mapEach };

package/dist/Map/mapEach.js

@@ -0,0 +1,44 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneMap } from "@monstermann/remmi";
+
+//#region src/Map/mapEach.ts
+/**
+* `Map.mapEach(map, fn)`
+*
+* Maps each value in `map` using `fn`, returning a new map with the transformed values.
+*
+* ## Example
+*
+* ```ts
+* Map.mapEach(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     (value, key) => value * 2,
+* ); // Map(2) { "a" => 2, "b" => 4 }
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.mapEach((value, key) => value * 2),
+* ); // Map(2) { "a" => 2, "b" => 4 }
+* ```
+*/
+const mapEach = dfdlT((target, fn) => {
+	let result;
+	for (const [k, prev] of target) {
+		const next = fn(prev, k, target);
+		if (prev === next) continue;
+		result ??= cloneMap(target);
+		result.set(k, next);
+	}
+	return result ?? target;
+}, 2);
+
+//#endregion
+export { mapEach };

package/dist/Map/mapOr.d.ts

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

package/dist/Map/mapOr.js

@@ -0,0 +1,63 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneMap } from "@monstermann/remmi";
+
+//#region src/Map/mapOr.ts
+/**
+* `Map.mapOr(map, key, transform, or)`
+*
+* Transforms the value at `key` in `map` using `transform`, returning `or` if the key doesn't exist.
+*
+* ## Example
+*
+* ```ts
+* Map.mapOr(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "a",
+*     (value) => value * 2,
+*     null,
+* ); // Map(2) { "a" => 2, "b" => 2 }
+*
+* Map.mapOr(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "c",
+*     (value) => value * 2,
+*     null,
+* ); // null
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.mapOr("a", (value) => value * 2, null),
+* ); // Map(2) { "a" => 2, "b" => 2 }
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.mapOr("c", (value) => value * 2, null),
+* ); // null
+* ```
+*/
+const mapOr = dfdlT((target, key, transform, or) => {
+	if (!target.has(key)) return or;
+	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 { mapOr };