@monstermann/map 0.0.0

package/dist/Map/getOrElse.js

@@ -0,0 +1,71 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/getOrElse.ts
+/**
+* `Map.getOrElse(map, key, orElse)`
+*
+* Gets the value associated with `key` from `map`, calling `orElse` with the map if the key doesn't exist or the value is nullable.
+*
+* ## Example
+*
+* ```ts
+* Map.getOrElse(
+*     Map.create([
+*         ["a", 1],
+*         ["b", null],
+*     ]),
+*     "a",
+*     () => 0,
+* ); // 1
+*
+* Map.getOrElse(
+*     Map.create([
+*         ["a", 1],
+*         ["b", null],
+*     ]),
+*     "b",
+*     () => 0,
+* ); // 0
+*
+* Map.getOrElse(
+*     Map.create([
+*         ["a", 1],
+*         ["b", null],
+*     ]),
+*     "c",
+*     (map) => map.size,
+* ); // 2
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", null],
+*     ]),
+*     Map.getOrElse("a", () => 0),
+* ); // 1
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", null],
+*     ]),
+*     Map.getOrElse("b", () => 0),
+* ); // 0
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", null],
+*     ]),
+*     Map.getOrElse("c", (map) => map.size),
+* ); // 2
+* ```
+*/
+const getOrElse = dfdlT((target, key, orElse) => {
+	return target.get(key) ?? orElse(target);
+}, 3);
+
+//#endregion
+export { getOrElse };

package/dist/Map/getOrThrow.d.ts

@@ -0,0 +1,69 @@
+import { NonNil } from "./internals/types.js";
+
+//#region src/Map/getOrThrow.d.ts
+
+/**
+ * `Map.getOrThrow(map, key)`
+ *
+ * Gets the value associated with `key` from `map`, throwing an error if the key doesn't exist or the value is nullable.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.getOrThrow(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "a",
+ * ); // 1
+ *
+ * Map.getOrThrow(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", null],
+ *     ]),
+ *     "b",
+ * ); // throws FnError
+ *
+ * Map.getOrThrow(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "c",
+ * ); // throws FnError
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.getOrThrow("a"),
+ * ); // 1
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", null],
+ *     ]),
+ *     Map.getOrThrow("b"),
+ * ); // throws FnError
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.getOrThrow("c"),
+ * ); // throws FnError
+ * ```
+ */
+declare const getOrThrow: {
+  <K, V>(key: NoInfer<K>): (target: ReadonlyMap<K, V>) => NonNil<V>;
+  <K, V>(target: ReadonlyMap<K, V>, key: NoInfer<K>): NonNil<V>;
+};
+//#endregion
+export { getOrThrow };

package/dist/Map/getOrThrow.js

@@ -0,0 +1,70 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/getOrThrow.ts
+/**
+* `Map.getOrThrow(map, key)`
+*
+* Gets the value associated with `key` from `map`, throwing an error if the key doesn't exist or the value is nullable.
+*
+* ## Example
+*
+* ```ts
+* Map.getOrThrow(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "a",
+* ); // 1
+*
+* Map.getOrThrow(
+*     Map.create([
+*         ["a", 1],
+*         ["b", null],
+*     ]),
+*     "b",
+* ); // throws FnError
+*
+* Map.getOrThrow(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "c",
+* ); // throws FnError
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.getOrThrow("a"),
+* ); // 1
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", null],
+*     ]),
+*     Map.getOrThrow("b"),
+* ); // throws FnError
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.getOrThrow("c"),
+* ); // throws FnError
+* ```
+*/
+const getOrThrow = dfdlT((target, key) => {
+	const value = target.get(key);
+	if (value != null) return value;
+	throw new Error("Map.getOrThrow: Value not found.");
+}, 2);
+
+//#endregion
+export { getOrThrow };

package/dist/Map/has.d.ts

@@ -0,0 +1,50 @@
+//#region src/Map/has.d.ts
+/**
+ * `Map.has(map, key)`
+ *
+ * Checks if `map` contains the specified `key`.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.has(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "a",
+ * ); // true
+ *
+ * Map.has(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "c",
+ * ); // false
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.has("a"),
+ * ); // true
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.has("c"),
+ * ); // false
+ * ```
+ */
+declare const has: {
+  <K, V>(key: NoInfer<K>): (target: ReadonlyMap<K, V>) => boolean;
+  <K, V>(target: ReadonlyMap<K, V>, key: NoInfer<K>): boolean;
+};
+//#endregion
+export { has };

package/dist/Map/has.js

@@ -0,0 +1,52 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/has.ts
+/**
+* `Map.has(map, key)`
+*
+* Checks if `map` contains the specified `key`.
+*
+* ## Example
+*
+* ```ts
+* Map.has(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "a",
+* ); // true
+*
+* Map.has(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     "c",
+* ); // false
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.has("a"),
+* ); // true
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.has("c"),
+* ); // false
+* ```
+*/
+const has = dfdlT((target, key) => {
+	return target.has(key);
+}, 2);
+
+//#endregion
+export { has };

package/dist/Map/hasAll.d.ts

@@ -0,0 +1,54 @@
+//#region src/Map/hasAll.d.ts
+/**
+ * `Map.hasAll(map, keys)`
+ *
+ * Checks if `map` contains all of the specified `keys`. This function supports iterables.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.hasAll(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     ["a", "b"],
+ * ); // true
+ *
+ * Map.hasAll(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     ["a", "d"],
+ * ); // false
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.hasAll(["a", "b"]),
+ * ); // true
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.hasAll(["a", "d"]),
+ * ); // false
+ * ```
+ */
+declare const hasAll: {
+  <K, V>(keys: Iterable<NoInfer<K>>): (target: ReadonlyMap<K, V>) => boolean;
+  <K, V>(target: ReadonlyMap<K, V>, keys: Iterable<NoInfer<K>>): boolean;
+};
+//#endregion
+export { hasAll };

package/dist/Map/hasAll.js

@@ -0,0 +1,57 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/hasAll.ts
+/**
+* `Map.hasAll(map, keys)`
+*
+* Checks if `map` contains all of the specified `keys`. This function supports iterables.
+*
+* ## Example
+*
+* ```ts
+* Map.hasAll(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     ["a", "b"],
+* ); // true
+*
+* Map.hasAll(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     ["a", "d"],
+* ); // false
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     Map.hasAll(["a", "b"]),
+* ); // true
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     Map.hasAll(["a", "d"]),
+* ); // false
+* ```
+*/
+const hasAll = dfdlT((target, keys) => {
+	for (const key of keys) if (!target.has(key)) return false;
+	return true;
+}, 2);
+
+//#endregion
+export { hasAll };

package/dist/Map/hasAny.d.ts

@@ -0,0 +1,50 @@
+//#region src/Map/hasAny.d.ts
+/**
+ * `Map.hasAny(map, keys)`
+ *
+ * Checks if `map` contains any of the specified `keys`. This function supports iterables.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.hasAny(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     ["a", "c"],
+ * ); // true
+ *
+ * Map.hasAny(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     ["c", "d"],
+ * ); // false
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.hasAny(["a", "c"]),
+ * ); // true
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.hasAny(["c", "d"]),
+ * ); // false
+ * ```
+ */
+declare const hasAny: {
+  <K, V>(keys: Iterable<NoInfer<K>>): (target: ReadonlyMap<K, V>) => boolean;
+  <K, V>(target: ReadonlyMap<K, V>, keys: Iterable<NoInfer<K>>): boolean;
+};
+//#endregion
+export { hasAny };

package/dist/Map/hasAny.js

@@ -0,0 +1,53 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/hasAny.ts
+/**
+* `Map.hasAny(map, keys)`
+*
+* Checks if `map` contains any of the specified `keys`. This function supports iterables.
+*
+* ## Example
+*
+* ```ts
+* Map.hasAny(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     ["a", "c"],
+* ); // true
+*
+* Map.hasAny(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     ["c", "d"],
+* ); // false
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.hasAny(["a", "c"]),
+* ); // true
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.hasAny(["c", "d"]),
+* ); // false
+* ```
+*/
+const hasAny = dfdlT((target, keys) => {
+	for (const key of keys) if (target.has(key)) return true;
+	return false;
+}, 2);
+
+//#endregion
+export { hasAny };

package/dist/Map/hasNone.d.ts

@@ -0,0 +1,50 @@
+//#region src/Map/hasNone.d.ts
+/**
+ * `Map.hasNone(map, keys)`
+ *
+ * Checks if `map` contains none of the specified `keys`. This function supports iterables.
+ *
+ * ## Example
+ *
+ * ```ts
+ * Map.hasNone(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     ["c", "d"],
+ * ); // true
+ *
+ * Map.hasNone(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     ["a", "c"],
+ * ); // false
+ * ```
+ *
+ * ```ts
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.hasNone(["c", "d"]),
+ * ); // true
+ *
+ * pipe(
+ *     Map.create([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.hasNone(["a", "c"]),
+ * ); // false
+ * ```
+ */
+declare const hasNone: {
+  <K, V>(keys: Iterable<NoInfer<K>>): (target: ReadonlyMap<K, V>) => boolean;
+  <K, V>(target: ReadonlyMap<K, V>, keys: Iterable<NoInfer<K>>): boolean;
+};
+//#endregion
+export { hasNone };

package/dist/Map/hasNone.js

@@ -0,0 +1,53 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/hasNone.ts
+/**
+* `Map.hasNone(map, keys)`
+*
+* Checks if `map` contains none of the specified `keys`. This function supports iterables.
+*
+* ## Example
+*
+* ```ts
+* Map.hasNone(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     ["c", "d"],
+* ); // true
+*
+* Map.hasNone(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     ["a", "c"],
+* ); // false
+* ```
+*
+* ```ts
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.hasNone(["c", "d"]),
+* ); // true
+*
+* pipe(
+*     Map.create([
+*         ["a", 1],
+*         ["b", 2],
+*     ]),
+*     Map.hasNone(["a", "c"]),
+* ); // false
+* ```
+*/
+const hasNone = dfdlT((target, keys) => {
+	for (const key of keys) if (target.has(key)) return false;
+	return true;
+}, 2);
+
+//#endregion
+export { hasNone };

package/dist/Map/index.d.ts

@@ -0,0 +1,35 @@
+import { clone } from "./clone.js";
+import { compact } from "./compact.js";
+import { filter } from "./filter.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.d.ts
+
+declare namespace Map {
+  export { 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 };