@monstermann/map 0.1.1 → 0.2.0

package/dist/Map/mapOr.d.ts

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

@@ -1,71 +0,0 @@
-import { MapMap, OrElse } from "./internals/types.js";
-
-//#region src/Map/mapOrElse.d.ts
-
-/**
- * ```ts
- * function Map.mapOrElse(map, key, transform, orElse)
- * ```
- *
- * ## Example
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * Map.mapOrElse(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *     ]),
- *     "a",
- *     (value) => value * 2,
- *     () => null,
- * ); // Map(2) { "a" => 2, "b" => 2 }
- *
- * Map.mapOrElse(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *     ]),
- *     "c",
- *     (value) => value * 2,
- *     (map) => map.size,
- * ); // 2
- * ```
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * pipe(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *     ]),
- *     Map.mapOrElse(
- *         "a",
- *         (value) => value * 2,
- *         () => null,
- *     ),
- * ); // Map(2) { "a" => 2, "b" => 2 }
- *
- * pipe(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *     ]),
- *     Map.mapOrElse(
- *         "c",
- *         (value) => value * 2,
- *         (map) => map.size,
- *     ),
- * ); // 2
- * ```
- */
-declare const mapOrElse: {
-  <K, V, U>(key: NoInfer<K>, transform: MapMap<K, V>, orElse: OrElse<K, V, U>): (target: Map<K, V>) => Map<K, V> | U;
-  <K, V, U>(key: NoInfer<K>, transform: MapMap<K, V>, orElse: OrElse<K, V, U>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V> | U;
-  <K, V, U>(target: Map<K, V>, key: NoInfer<K>, transform: MapMap<K, V>, orElse: OrElse<K, V, U>): Map<K, V> | U;
-  <K, V, U>(target: ReadonlyMap<K, V>, key: NoInfer<K>, transform: MapMap<K, V>, orElse: OrElse<K, V, U>): ReadonlyMap<K, V> | U;
-};
-//#endregion
-export { mapOrElse };

package/dist/Map/mapOrThrow.d.ts

@@ -1,61 +0,0 @@
-import { MapMap } from "./internals/types.js";
-
-//#region src/Map/mapOrThrow.d.ts
-
-/**
- * ```ts
- * function Map.mapOrThrow(map, key, transform)
- * ```
- *
- * ## Example
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * Map.mapOrThrow(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *     ]),
- *     "a",
- *     (value) => value * 2,
- * ); // Map(2) { "a" => 2, "b" => 2 }
- *
- * Map.mapOrThrow(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *     ]),
- *     "c",
- *     (value) => value * 2,
- * ); // throws FnError
- * ```
- *
- * ```ts
- * import { Map } from "@monstermann/map";
- *
- * pipe(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *     ]),
- *     Map.mapOrThrow("a", (value) => value * 2),
- * ); // Map(2) { "a" => 2, "b" => 2 }
- *
- * pipe(
- *     Map.create([
- *         ["a", 1],
- *         ["b", 2],
- *     ]),
- *     Map.mapOrThrow("c", (value) => value * 2),
- * ); // throws FnError
- * ```
- */
-declare const mapOrThrow: {
-  <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 { mapOrThrow };

package/dist/Map/reject.d.ts

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

package/dist/index.d.ts

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

package/dist/index.js

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