@monstermann/map 0.1.1 → 0.2.0

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

@@ -1,16 +1,24 @@
 //#region src/Map/set.d.ts
 /**
+ * # set
+ *
  * ```ts
- * function Map.set(map, key, value)
+ * function Map.set<K, V>(
+ *     target: ReadonlyMap<K, V>,
+ *     key: NoInfer<K>,
+ *     value: NoInfer<V>,
+ * ): ReadonlyMap<K, V>
  * ```
  *
+ * Sets or updates the value for the specified key in the map.
+ *
  * ## Example
  *
- * ```ts
+ * ```ts [data-first]
  * import { Map } from "@monstermann/map";
  *
  * Map.set(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -19,7 +27,7 @@
  * ); // Map(2) { "a" => 10, "b" => 2 }
  *
  * Map.set(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -28,11 +36,11 @@
  * ); // Map(3) { "a" => 1, "b" => 2, "c" => 3 }
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Map } from "@monstermann/map";
  *
  * pipe(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -40,13 +48,14 @@
  * ); // Map(2) { "a" => 10, "b" => 2 }
  *
  * pipe(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
  *     Map.set("c", 3),
  * ); // Map(3) { "a" => 1, "b" => 2, "c" => 3 }
  * ```
+ *
  */
 declare const set: {
   <K, V>(key: NoInfer<K>, value: NoInfer<V>): (target: Map<K, V>) => Map<K, V>;

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

@@ -3,17 +3,25 @@ import { cloneMap } from "@monstermann/remmi";
 
 //#region src/Map/set.ts
 /**
+* # set
+*
 * ```ts
-* function Map.set(map, key, value)
+* function Map.set<K, V>(
+*     target: ReadonlyMap<K, V>,
+*     key: NoInfer<K>,
+*     value: NoInfer<V>,
+* ): ReadonlyMap<K, V>
 * ```
 *
+* Sets or updates the value for the specified key in the map.
+*
 * ## Example
 *
-* ```ts
+* ```ts [data-first]
 * import { Map } from "@monstermann/map";
 *
 * Map.set(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -22,7 +30,7 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(2) { "a" => 10, "b" => 2 }
 *
 * Map.set(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -31,11 +39,11 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(3) { "a" => 1, "b" => 2, "c" => 3 }
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Map } from "@monstermann/map";
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -43,13 +51,14 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(2) { "a" => 10, "b" => 2 }
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
 *     Map.set("c", 3),
 * ); // Map(3) { "a" => 1, "b" => 2, "c" => 3 }
 * ```
+*
 */
 const set = dfdlT((target, key, value) => {
 	if (target.get(key) === value) return target;

package/dist/Map/some.d.mts

@@ -0,0 +1,52 @@
+//#region src/Map/some.d.ts
+/**
+ * # some
+ *
+ * ```ts
+ * function Map.some<K, V>(
+ *     target: ReadonlyMap<K, V>,
+ *     predicate: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => boolean,
+ * ): boolean
+ * ```
+ *
+ * Returns `true` if at least one entry in the map satisfies the provided `predicate` function, otherwise returns `false`.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Map } from "@monstermann/map";
+ *
+ * Map.some(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     (value) => value > 2,
+ * ); // true
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Map } from "@monstermann/map";
+ *
+ * pipe(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.some((value) => value > 2),
+ * ); // true
+ * ```
+ *
+ */
+declare const some: {
+  <K, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): (target: ReadonlyMap<K, V>) => boolean;
+  <K, V>(target: ReadonlyMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): boolean;
+};
+//#endregion
+export { some };

package/dist/Map/some.mjs

@@ -0,0 +1,55 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/some.ts
+/**
+* # some
+*
+* ```ts
+* function Map.some<K, V>(
+*     target: ReadonlyMap<K, V>,
+*     predicate: (
+*         value: NoInfer<V>,
+*         key: NoInfer<K>,
+*         target: ReadonlyMap<K, V>,
+*     ) => boolean,
+* ): boolean
+* ```
+*
+* Returns `true` if at least one entry in the map satisfies the provided `predicate` function, otherwise returns `false`.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Map } from "@monstermann/map";
+*
+* Map.some(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     (value) => value > 2,
+* ); // true
+* ```
+*
+* ```ts [data-last]
+* import { Map } from "@monstermann/map";
+*
+* pipe(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     Map.some((value) => value > 2),
+* ); // true
+* ```
+*
+*/
+const some = dfdlT((target, predicate) => {
+	for (const [key, value] of target) if (predicate(value, key, target)) return true;
+	return false;
+}, 2);
+
+//#endregion
+export { some };

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { Map } from "./Map/index.mjs";
+export { Map };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { Map } from "./Map/index.mjs";
+
+export { Map };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@monstermann/map",
     "type": "module",
-    "version": "0.1.1",
+    "version": "0.2.0",
     "description": "Functional utilities for maps.",
     "author": "Michael Ostermann <michaelostermann@me.com>",
     "license": "MIT",
@@ -34,6 +34,6 @@
     },
     "dependencies": {
         "@monstermann/dfdl": "^0.1.0",
-        "@monstermann/remmi": "^0.0.0"
+        "@monstermann/remmi": "^0.1.0"
     }
 }

package/dist/Map/compact.d.ts

@@ -1,44 +0,0 @@
-import { NonNil } from "./internals/types.js";
-
-//#region src/Map/compact.d.ts
-
-/**
- * ```ts
- * function Map.compact(map)
- * ```
- *
- * ## Example
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * Map.compact(
- *     Map.create([
- *         ["a", 1],
- *         ["b", null],
- *         ["c", undefined],
- *     ]),
- * ); // Map(1) { "a" => 1 }
- * ```
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * pipe(
- *     Map.create([
- *         ["a", 1],
- *         ["b", null],
- *         ["c", undefined],
- *     ]),
- *     Map.compact(),
- * ); // Map(1) { "a" => 1 }
- * ```
- */
-declare const compact: {
-  (): <K, V>(target: Map<K, V>) => Map<K, NonNil<V>>;
-  (): <K, V>(target: ReadonlyMap<K, V>) => ReadonlyMap<K, NonNil<V>>;
-  <K, V>(target: Map<K, V>): Map<K, NonNil<V>>;
-  <K, V>(target: ReadonlyMap<K, V>): ReadonlyMap<K, NonNil<V>>;
-};
-//#endregion
-export { compact };

package/dist/Map/filter.d.ts

@@ -1,49 +0,0 @@
-import { MapGuard, MapPredicate } from "./internals/types.js";
-
-//#region src/Map/filter.d.ts
-
-/**
- * ```ts
- * function Map.filter(map, predicate)
- * ```
- *
- * ## Example
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * Map.filter(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *         ["c", 3],
- *     ]),
- *     (value) => value > 1,
- * ); // Map(2) { "b" => 2, "c" => 3 }
- * ```
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * pipe(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *         ["c", 3],
- *     ]),
- *     Map.filter((value) => value > 1),
- * ); // Map(2) { "b" => 2, "c" => 3 }
- * ```
- */
-declare const filter: {
-  <K, V, U extends V>(predicate: MapGuard<K, V, U>): (target: Map<K, V>) => Map<K, U>;
-  <K, V, U extends V>(predicate: MapGuard<K, V, U>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, U>;
-  <K, V>(predicate: MapPredicate<K, V>): (target: Map<K, V>) => Map<K, V>;
-  <K, V>(predicate: MapPredicate<K, V>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-  <K, V, U extends V>(target: Map<K, V>, predicate: MapGuard<K, V, U>): Map<K, U>;
-  <K, V, U extends V>(target: ReadonlyMap<K, V>, predicate: MapGuard<K, V, U>): ReadonlyMap<K, U>;
-  <K, V>(target: Map<K, V>, predicate: MapPredicate<K, V>): Map<K, V>;
-  <K, V>(target: ReadonlyMap<K, V>, predicate: MapPredicate<K, V>): ReadonlyMap<K, V>;
-};
-//#endregion
-export { filter };

package/dist/Map/forEach.d.ts

@@ -1,43 +0,0 @@
-import { MapMap } from "./internals/types.js";
-
-//#region src/Map/forEach.d.ts
-
-/**
- * ```ts
- * function Map.forEach(map, fn)
- * ```
- *
- * ## Example
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * Map.forEach(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *     ]),
- *     (value, key) => console.log(key, value),
- * ); // Map(2) { "a" => 1, "b" => 2 }
- * ```
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * pipe(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *     ]),
- *     Map.forEach((value, key) => console.log(key, value)),
- * ); // Map(2) { "a" => 1, "b" => 2 }
- * ```
- */
-declare const forEach: {
-  <K, V>(fn: MapMap<K, V, any>): (target: Map<K, V>) => Map<K, V>;
-  <K, V>(fn: MapMap<K, V, any>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-  <K, V>(target: Map<K, V>, fn: MapMap<K, V, any>): Map<K, V>;
-  <K, V>(target: ReadonlyMap<K, V>, fn: MapMap<K, V, any>): ReadonlyMap<K, V>;
-};
-//#endregion
-export { forEach };

package/dist/Map/index.d.ts

@@ -1,36 +0,0 @@
-import { clone } from "./clone.js";
-import { compact } from "./compact.js";
-import { create } from "./create.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 { is } from "./is.js";
-import { isEmpty } from "./isEmpty.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, create, filter, forEach, get, getOr, getOrElse, getOrThrow, has, hasAll, hasAny, hasNone, is, isEmpty, isShallowEqual, map, mapEach, mapOr, mapOrElse, mapOrThrow, reject, remove, removeAll, removeOr, removeOrElse, removeOrThrow, set };
-}
-//#endregion
-export { Map };

package/dist/Map/index.js

@@ -1,63 +0,0 @@
-import { clone } from "./clone.js";
-import { filter } from "./filter.js";
-import { compact } from "./compact.js";
-import { create } from "./create.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 { is } from "./is.js";
-import { isEmpty } from "./isEmpty.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,
-	create,
-	filter,
-	forEach,
-	get,
-	getOr,
-	getOrElse,
-	getOrThrow,
-	has,
-	hasAll,
-	hasAny,
-	hasNone,
-	is,
-	isEmpty,
-	isShallowEqual,
-	map,
-	mapEach,
-	mapOr,
-	mapOrElse,
-	mapOrThrow,
-	reject,
-	remove,
-	removeAll,
-	removeOr,
-	removeOrElse,
-	removeOrThrow,
-	set
-};
-
-//#endregion
-export { Map };

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

@@ -1,14 +0,0 @@
-//#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

@@ -1,28 +0,0 @@
-//#region src/Map/isEmpty.d.ts
-/**
- * ```ts
- * function Map.isEmpty(map)
- * ```
- *
- * ## Example
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * Map.isEmpty(Map.create()); // true
- * Map.isEmpty(Map.create([["a", 1]])); // false
- * ```
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * 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

@@ -1,30 +0,0 @@
-import { dfdlT } from "@monstermann/dfdl";
-
-//#region src/Map/isEmpty.ts
-/**
-* ```ts
-* function Map.isEmpty(map)
-* ```
-*
-* ## Example
-*
-* ```ts
-* import { Map } from "@monstermann/map";
-*
-* Map.isEmpty(Map.create()); // true
-* Map.isEmpty(Map.create([["a", 1]])); // false
-* ```
-*
-* ```ts
-* import { Map } from "@monstermann/map";
-*
-* 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/map.d.ts

@@ -1,60 +0,0 @@
-import { MapMap } from "./internals/types.js";
-
-//#region src/Map/map.d.ts
-
-/**
- * ```ts
- * function Map.map(map, key, transform)
- * ```
- *
- * ## Example
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * 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
- * import { Map } from "@monstermann/map";
- *
- * 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/mapEach.d.ts

@@ -1,43 +0,0 @@
-import { MapMap } from "./internals/types.js";
-
-//#region src/Map/mapEach.d.ts
-
-/**
- * ```ts
- * function Map.mapEach(map, fn)
- * ```
- *
- * ## Example
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * Map.mapEach(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *     ]),
- *     (value, key) => value * 2,
- * ); // Map(2) { "a" => 2, "b" => 4 }
- * ```
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * 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 };