@monstermann/map 0.1.2 → 0.2.0

package/dist/Map/index.mjs

@@ -2,6 +2,24 @@ 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";
@@ -19,6 +37,7 @@ 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";
@@ -26,13 +45,32 @@ 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,
@@ -50,13 +88,15 @@ const Map = {
 	mapOr,
 	mapOrElse,
 	mapOrThrow,
+	none,
 	reject,
 	remove,
 	removeAll,
 	removeOr,
 	removeOrElse,
 	removeOrThrow,
-	set
+	set,
+	some
 };
 
 //#endregion

package/dist/Map/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.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

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

package/dist/Map/isEmpty.mjs

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

package/dist/Map/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.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

@@ -1,19 +1,28 @@
-import { MapMap } from "./internals/types.mjs";
-
 //#region src/Map/map.d.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 +31,7 @@ import { MapMap } from "./internals/types.mjs";
  * ); // Map(2) { "a" => 2, "b" => 2 }
  *
  * Map.map(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -31,11 +40,11 @@ import { MapMap } from "./internals/types.mjs";
  * ); // 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,18 +52,20 @@ import { MapMap } from "./internals/types.mjs";
  * ); // 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 }
  * ```
+ *
  */
 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>;
+  <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.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

@@ -1,19 +1,27 @@
-import { MapMap } from "./internals/types.mjs";
-
 //#region src/Map/mapEach.d.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,23 +29,24 @@ import { MapMap } from "./internals/types.mjs";
  * ); // 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 }
  * ```
+ *
  */
 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>;
+  <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.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;