@monstermann/map 0.1.1 → 0.2.0

package/dist/Map/index.mjs

@@ -0,0 +1,103 @@
+import { clone } from "./clone.mjs";
+import { filter } from "./filter.mjs";
+import { compact } from "./compact.mjs";
+import { create } from "./create.mjs";
+import { every } from "./every.mjs";
+import { find } from "./find.mjs";
+import { findMap } from "./findMap.mjs";
+import { findMapAll } from "./findMapAll.mjs";
+import { findMapOr } from "./findMapOr.mjs";
+import { findMapOrElse } from "./findMapOrElse.mjs";
+import { findMapOrThrow } from "./findMapOrThrow.mjs";
+import { findOr } from "./findOr.mjs";
+import { findOrElse } from "./findOrElse.mjs";
+import { findOrThrow } from "./findOrThrow.mjs";
+import { findRemove } from "./findRemove.mjs";
+import { findRemoveOr } from "./findRemoveOr.mjs";
+import { findRemoveOrElse } from "./findRemoveOrElse.mjs";
+import { findRemoveOrThrow } from "./findRemoveOrThrow.mjs";
+import { findReplace } from "./findReplace.mjs";
+import { findReplaceOr } from "./findReplaceOr.mjs";
+import { findReplaceOrElse } from "./findReplaceOrElse.mjs";
+import { findReplaceOrThrow } from "./findReplaceOrThrow.mjs";
+import { forEach } from "./forEach.mjs";
+import { get } from "./get.mjs";
+import { getOr } from "./getOr.mjs";
+import { getOrElse } from "./getOrElse.mjs";
+import { getOrThrow } from "./getOrThrow.mjs";
+import { has } from "./has.mjs";
+import { hasAll } from "./hasAll.mjs";
+import { hasAny } from "./hasAny.mjs";
+import { hasNone } from "./hasNone.mjs";
+import { is } from "./is.mjs";
+import { isEmpty } from "./isEmpty.mjs";
+import { isShallowEqual } from "./isShallowEqual.mjs";
+import { map } from "./map.mjs";
+import { mapEach } from "./mapEach.mjs";
+import { mapOr } from "./mapOr.mjs";
+import { mapOrElse } from "./mapOrElse.mjs";
+import { mapOrThrow } from "./mapOrThrow.mjs";
+import { none } from "./none.mjs";
+import { reject } from "./reject.mjs";
+import { remove } from "./remove.mjs";
+import { removeAll } from "./removeAll.mjs";
+import { removeOr } from "./removeOr.mjs";
+import { removeOrElse } from "./removeOrElse.mjs";
+import { removeOrThrow } from "./removeOrThrow.mjs";
+import { set } from "./set.mjs";
+import { some } from "./some.mjs";
+
+//#region src/Map/index.js
+const Map = {
+	clone,
+	compact,
+	create,
+	every,
+	filter,
+	find,
+	findMap,
+	findMapAll,
+	findMapOr,
+	findMapOrElse,
+	findMapOrThrow,
+	findOr,
+	findOrElse,
+	findOrThrow,
+	findRemove,
+	findRemoveOr,
+	findRemoveOrElse,
+	findRemoveOrThrow,
+	findReplace,
+	findReplaceOr,
+	findReplaceOrElse,
+	findReplaceOrThrow,
+	forEach,
+	get,
+	getOr,
+	getOrElse,
+	getOrThrow,
+	has,
+	hasAll,
+	hasAny,
+	hasNone,
+	is,
+	isEmpty,
+	isShallowEqual,
+	map,
+	mapEach,
+	mapOr,
+	mapOrElse,
+	mapOrThrow,
+	none,
+	reject,
+	remove,
+	removeAll,
+	removeOr,
+	removeOrElse,
+	removeOrThrow,
+	set,
+	some
+};
+
+//#endregion
+export { Map };

package/dist/Map/{is.d.ts → is.d.mts}

@@ -1,26 +1,33 @@
 //#region src/Map/is.d.ts
 /**
+ * # is
+ *
  * ```ts
- * function Map.is(target)
+ * function Map.is(
+ *     target: unknown,
+ * ): target is Map<unknown, unknown>
  * ```
  *
+ * Type guard that checks whether a value is a Map instance.
+ *
  * ## Example
  *
- * ```ts
+ * ```ts [data-first]
  * import { Map } from "@monstermann/map";
  *
- * Map.is(Map.create()); // true
+ * Map.is(new Map()); // true
  * Map.is({}); // false
  * Map.is([]); // false
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Map } from "@monstermann/map";
  *
- * pipe(Map.create(), Map.is()); // true
+ * pipe(new Map(), Map.is()); // true
  * pipe({}, Map.is()); // false
  * pipe([], Map.is()); // false
  * ```
+ *
  */
 declare const is: {
   (): (target: unknown) => target is Map<unknown, unknown>;

package/dist/Map/{is.js → is.mjs}

@@ -2,27 +2,34 @@ import { dfdlT } from "@monstermann/dfdl";
 
 //#region src/Map/is.ts
 /**
+* # is
+*
 * ```ts
-* function Map.is(target)
+* function Map.is(
+*     target: unknown,
+* ): target is Map<unknown, unknown>
 * ```
 *
+* Type guard that checks whether a value is a Map instance.
+*
 * ## Example
 *
-* ```ts
+* ```ts [data-first]
 * import { Map } from "@monstermann/map";
 *
-* Map.is(Map.create()); // true
+* Map.is(new Map()); // true
 * Map.is({}); // false
 * Map.is([]); // false
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Map } from "@monstermann/map";
 *
-* pipe(Map.create(), Map.is()); // true
+* pipe(new Map(), Map.is()); // true
 * pipe({}, Map.is()); // false
 * pipe([], Map.is()); // false
 * ```
+*
 */
 const is = dfdlT((target) => {
 	return target instanceof Map;

package/dist/Map/isEmpty.d.mts

@@ -0,0 +1,33 @@
+//#region src/Map/isEmpty.d.ts
+/**
+ * # isEmpty
+ *
+ * ```ts
+ * function Map.isEmpty<T, U>(target: ReadonlyMap<T, U>): boolean
+ * ```
+ *
+ * Checks whether the map is empty (contains no entries).
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Map } from "@monstermann/map";
+ *
+ * Map.isEmpty(new Map()); // true
+ * Map.isEmpty(new Map([["a", 1]])); // false
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Map } from "@monstermann/map";
+ *
+ * pipe(new Map(), Map.isEmpty()); // true
+ * pipe(new Map([["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.mjs

@@ -0,0 +1,35 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/isEmpty.ts
+/**
+* # isEmpty
+*
+* ```ts
+* function Map.isEmpty<T, U>(target: ReadonlyMap<T, U>): boolean
+* ```
+*
+* Checks whether the map is empty (contains no entries).
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Map } from "@monstermann/map";
+*
+* Map.isEmpty(new Map()); // true
+* Map.isEmpty(new Map([["a", 1]])); // false
+* ```
+*
+* ```ts [data-last]
+* import { Map } from "@monstermann/map";
+*
+* pipe(new Map(), Map.isEmpty()); // true
+* pipe(new Map([["a", 1]]), Map.isEmpty()); // false
+* ```
+*
+*/
+const isEmpty = dfdlT((target) => {
+	return target.size === 0;
+}, 1);
+
+//#endregion
+export { isEmpty };

package/dist/Map/{isShallowEqual.d.ts → isShallowEqual.d.mts}

@@ -1,47 +1,54 @@
 //#region src/Map/isShallowEqual.d.ts
 /**
+ * # isShallowEqual
+ *
  * ```ts
- * function Map.isShallowEqual(map, source)
+ * function Map.isShallowEqual<K, V>(
+ *     target: ReadonlyMap<K, V>,
+ *     source: ReadonlyMap<NoInfer<K>, NoInfer<V>>,
+ * ): boolean
  * ```
  *
+ * Checks whether two maps are shallowly equal (same keys and values using strict equality).
+ *
  * ## Example
  *
- * ```ts
+ * ```ts [data-first]
  * import { Map } from "@monstermann/map";
  *
  * Map.isShallowEqual(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
  * ); // true
  *
  * Map.isShallowEqual(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 3],
  *     ]),
  * ); // false
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Map } from "@monstermann/map";
  *
  * pipe(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
  *     Map.isShallowEqual(
- *         Map.create([
+ *         new Map([
  *             ["a", 1],
  *             ["b", 2],
  *         ]),
@@ -49,18 +56,19 @@
  * ); // true
  *
  * pipe(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
  *     Map.isShallowEqual(
- *         Map.create([
+ *         new Map([
  *             ["a", 1],
  *             ["b", 3],
  *         ]),
  *     ),
  * ); // false
  * ```
+ *
  */
 declare const isShallowEqual: {
   <K, V>(source: ReadonlyMap<NoInfer<K>, NoInfer<V>>): (target: ReadonlyMap<K, V>) => boolean;

package/dist/Map/{isShallowEqual.js → isShallowEqual.mjs}

@@ -2,48 +2,55 @@ import { dfdlT } from "@monstermann/dfdl";
 
 //#region src/Map/isShallowEqual.ts
 /**
+* # isShallowEqual
+*
 * ```ts
-* function Map.isShallowEqual(map, source)
+* function Map.isShallowEqual<K, V>(
+*     target: ReadonlyMap<K, V>,
+*     source: ReadonlyMap<NoInfer<K>, NoInfer<V>>,
+* ): boolean
 * ```
 *
+* Checks whether two maps are shallowly equal (same keys and values using strict equality).
+*
 * ## Example
 *
-* ```ts
+* ```ts [data-first]
 * import { Map } from "@monstermann/map";
 *
 * Map.isShallowEqual(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
 * ); // true
 *
 * Map.isShallowEqual(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 3],
 *     ]),
 * ); // false
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Map } from "@monstermann/map";
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
 *     Map.isShallowEqual(
-*         Map.create([
+*         new Map([
 *             ["a", 1],
 *             ["b", 2],
 *         ]),
@@ -51,18 +58,19 @@ import { dfdlT } from "@monstermann/dfdl";
 * ); // true
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
 *     Map.isShallowEqual(
-*         Map.create([
+*         new Map([
 *             ["a", 1],
 *             ["b", 3],
 *         ]),
 *     ),
 * ); // false
 * ```
+*
 */
 const isShallowEqual = dfdlT((target, source) => {
 	if (target.size !== source.size) return false;

package/dist/Map/map.d.mts

@@ -0,0 +1,71 @@
+//#region src/Map/map.d.ts
+/**
+ * # map
+ *
+ * ```ts
+ * function Map.map<K, V>(
+ *     target: ReadonlyMap<K, V>,
+ *     key: NoInfer<K>,
+ *     transform: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => V,
+ * ): ReadonlyMap<K, V>
+ * ```
+ *
+ * Transforms the value at the specified key using the provided function. Returns the original map if the key doesn't exist.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Map } from "@monstermann/map";
+ *
+ * Map.map(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "a",
+ *     (value) => value * 2,
+ * ); // Map(2) { "a" => 2, "b" => 2 }
+ *
+ * Map.map(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     "c",
+ *     (value) => value * 2,
+ * ); // Map(2) { "a" => 1, "b" => 2 }
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Map } from "@monstermann/map";
+ *
+ * pipe(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.map("a", (value) => value * 2),
+ * ); // Map(2) { "a" => 2, "b" => 2 }
+ *
+ * pipe(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.map("c", (value) => value * 2),
+ * ); // Map(2) { "a" => 1, "b" => 2 }
+ * ```
+ *
+ */
+declare const map: {
+  <K, V>(key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V): (target: Map<K, V>) => Map<K, V>;
+  <K, V>(key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  <K, V>(target: Map<K, V>, key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V): Map<K, V>;
+  <K, V>(target: ReadonlyMap<K, V>, key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V): ReadonlyMap<K, V>;
+};
+//#endregion
+export { map };

package/dist/Map/{map.js → map.mjs}

@@ -3,17 +3,29 @@ import { cloneMap } from "@monstermann/remmi";
 
 //#region src/Map/map.ts
 /**
+* # map
+*
 * ```ts
-* function Map.map(map, key, transform)
+* function Map.map<K, V>(
+*     target: ReadonlyMap<K, V>,
+*     key: NoInfer<K>,
+*     transform: (
+*         value: NoInfer<V>,
+*         key: NoInfer<K>,
+*         target: ReadonlyMap<K, V>,
+*     ) => V,
+* ): ReadonlyMap<K, V>
 * ```
 *
+* Transforms the value at the specified key using the provided function. Returns the original map if the key doesn't exist.
+*
 * ## Example
 *
-* ```ts
+* ```ts [data-first]
 * import { Map } from "@monstermann/map";
 *
 * Map.map(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -22,7 +34,7 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(2) { "a" => 2, "b" => 2 }
 *
 * Map.map(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -31,11 +43,11 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(2) { "a" => 1, "b" => 2 }
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Map } from "@monstermann/map";
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -43,12 +55,14 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(2) { "a" => 2, "b" => 2 }
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
 *     Map.map("c", (value) => value * 2),
+* ); // Map(2) { "a" => 1, "b" => 2 }
 * ```
+*
 */
 const map = dfdlT((target, key, transform) => {
 	if (!target.has(key)) return target;

package/dist/Map/mapEach.d.mts

@@ -0,0 +1,52 @@
+//#region src/Map/mapEach.d.ts
+/**
+ * # mapEach
+ *
+ * ```ts
+ * function Map.mapEach<K, V, U>(
+ *     target: ReadonlyMap<K, V>,
+ *     fn: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => U,
+ * ): ReadonlyMap<K, U>
+ * ```
+ *
+ * Transforms all values in the map using the provided function.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Map } from "@monstermann/map";
+ *
+ * Map.mapEach(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     (value, key) => value * 2,
+ * ); // Map(2) { "a" => 2, "b" => 4 }
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Map } from "@monstermann/map";
+ *
+ * pipe(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *     ]),
+ *     Map.mapEach((value, key) => value * 2),
+ * ); // Map(2) { "a" => 2, "b" => 4 }
+ * ```
+ *
+ */
+declare const mapEach: {
+  <K, V, U>(fn: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => U): (target: Map<K, V>) => Map<K, U>;
+  <K, V, U>(fn: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => U): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, U>;
+  <K, V, U>(target: Map<K, V>, fn: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => U): Map<K, U>;
+  <K, V, U>(target: ReadonlyMap<K, V>, fn: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => U): ReadonlyMap<K, U>;
+};
+//#endregion
+export { mapEach };

package/dist/Map/{mapEach.js → mapEach.mjs}

@@ -3,17 +3,28 @@ import { cloneMap } from "@monstermann/remmi";
 
 //#region src/Map/mapEach.ts
 /**
+* # mapEach
+*
 * ```ts
-* function Map.mapEach(map, fn)
+* function Map.mapEach<K, V, U>(
+*     target: ReadonlyMap<K, V>,
+*     fn: (
+*         value: NoInfer<V>,
+*         key: NoInfer<K>,
+*         target: ReadonlyMap<K, V>,
+*     ) => U,
+* ): ReadonlyMap<K, U>
 * ```
 *
+* Transforms all values in the map using the provided function.
+*
 * ## Example
 *
-* ```ts
+* ```ts [data-first]
 * import { Map } from "@monstermann/map";
 *
 * Map.mapEach(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -21,17 +32,18 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(2) { "a" => 2, "b" => 4 }
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Map } from "@monstermann/map";
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
 *     Map.mapEach((value, key) => value * 2),
 * ); // Map(2) { "a" => 2, "b" => 4 }
 * ```
+*
 */
 const mapEach = dfdlT((target, fn) => {
 	let result;