@helpers4/map 3.0.2-alpha.0 → 3.0.4

package/lib/index.d.ts

@@ -11,7 +11,7 @@
  * @example
  * countBy(new Map([['a', 1], ['b', 2], ['c', 3]]), value => value % 2 === 0 ? 'even' : 'odd')
  * // => Map(2) { 'odd' => 2, 'even' => 1 }
- * @since next
+ * @since 3.0.3
  */
 declare function countBy<K, V, R>(map: ReadonlyMap<K, V>, fn: (value: V, key: K) => R): Map<R, number>;
 
@@ -28,7 +28,7 @@ declare function countBy<K, V, R>(map: ReadonlyMap<K, V>, fn: (value: V, key: K)
  * @example
  * every(new Map([['a', 1], ['b', 2]]), value => value > 0)
  * // => true
- * @since next
+ * @since 3.0.3
  */
 declare function every<K, V>(map: ReadonlyMap<K, V>, predicate: (value: V, key: K) => boolean): boolean;
 
@@ -45,7 +45,7 @@ declare function every<K, V>(map: ReadonlyMap<K, V>, predicate: (value: V, key:
  * @example
  * filter(new Map([['a', 1], ['b', 2], ['c', 3]]), value => value % 2 === 0)
  * // => Map(1) { 'b' => 2 }
- * @since next
+ * @since 3.0.3
  */
 declare function filter<K, V>(map: ReadonlyMap<K, V>, predicate: (value: V, key: K) => boolean): Map<K, V>;
 
@@ -62,7 +62,7 @@ declare function filter<K, V>(map: ReadonlyMap<K, V>, predicate: (value: V, key:
  * @example
  * findKey(new Map([['a', 1], ['b', 2]]), value => value > 1)
  * // => 'b'
- * @since next
+ * @since 3.0.3
  */
 declare function findKey<K, V>(map: ReadonlyMap<K, V>, predicate: (value: V, key: K) => boolean): K | undefined;
 
@@ -79,7 +79,7 @@ declare function findKey<K, V>(map: ReadonlyMap<K, V>, predicate: (value: V, key
  * @example
  * findValue(new Map([['a', 1], ['b', 2]]), value => value > 1)
  * // => 2
- * @since next
+ * @since 3.0.3
  */
 declare function findValue<K, V>(map: ReadonlyMap<K, V>, predicate: (value: V, key: K) => boolean): V | undefined;
 
@@ -97,7 +97,7 @@ declare function findValue<K, V>(map: ReadonlyMap<K, V>, predicate: (value: V, k
  * @example
  * hasValue(new Map([['a', 1], ['b', 2]]), 2)
  * // => true
- * @since next
+ * @since 3.0.3
  */
 declare function hasValue<K, V>(map: ReadonlyMap<K, V>, value: V): boolean;
 
@@ -115,7 +115,7 @@ declare function hasValue<K, V>(map: ReadonlyMap<K, V>, value: V): boolean;
  * @example
  * mapKeys(new Map([['a', 1], ['b', 2]]), key => key.toUpperCase())
  * // => Map(2) { 'A' => 1, 'B' => 2 }
- * @since next
+ * @since 3.0.3
  */
 declare function mapKeys<K, V, R>(map: ReadonlyMap<K, V>, fn: (key: K, value: V) => R): Map<R, V>;
 
@@ -132,7 +132,7 @@ declare function mapKeys<K, V, R>(map: ReadonlyMap<K, V>, fn: (key: K, value: V)
  * @example
  * mapValues(new Map([['a', 1], ['b', 2]]), value => value * 10)
  * // => Map(2) { 'a' => 10, 'b' => 20 }
- * @since next
+ * @since 3.0.3
  */
 declare function mapValues<K, V, R>(map: ReadonlyMap<K, V>, fn: (value: V, key: K) => R): Map<K, R>;
 
@@ -150,7 +150,7 @@ declare function mapValues<K, V, R>(map: ReadonlyMap<K, V>, fn: (value: V, key:
  * @example
  * reduce(new Map([['a', 1], ['b', 2]]), (acc, value) => acc + value, 0)
  * // => 3
- * @since next
+ * @since 3.0.3
  */
 declare function reduce<K, V, R>(map: ReadonlyMap<K, V>, fn: (accumulator: R, value: V, key: K) => R, initial: R): R;
 
@@ -167,7 +167,7 @@ declare function reduce<K, V, R>(map: ReadonlyMap<K, V>, fn: (accumulator: R, va
  * @example
  * some(new Map([['a', 1], ['b', 2]]), value => value > 1)
  * // => true
- * @since next
+ * @since 3.0.3
  */
 declare function some<K, V>(map: ReadonlyMap<K, V>, predicate: (value: V, key: K) => boolean): boolean;
 
@@ -189,7 +189,7 @@ declare function some<K, V>(map: ReadonlyMap<K, V>, predicate: (value: V, key: K
  * @example
  * toMapByKey([{ id: 'a', n: 1 }, { id: 'b', n: 2 }], item => item.id)
  * // => Map(2) { 'a' => { id: 'a', n: 1 }, 'b' => { id: 'b', n: 2 } }
- * @since next
+ * @since 3.0.3
  */
 declare function toMapByKey<T, K>(items: Iterable<T>, fn: (item: T) => K): Map<K, T>;
 

package/lib/index.js

@@ -12,7 +12,7 @@
 * @example
 * countBy(new Map([['a', 1], ['b', 2], ['c', 3]]), value => value % 2 === 0 ? 'even' : 'odd')
 * // => Map(2) { 'odd' => 2, 'even' => 1 }
-* @since next
+* @since 3.0.3
 */
 function countBy(map, fn) {
 	const counts = /* @__PURE__ */ new Map();
@@ -37,7 +37,7 @@ function countBy(map, fn) {
 * @example
 * every(new Map([['a', 1], ['b', 2]]), value => value > 0)
 * // => true
-* @since next
+* @since 3.0.3
 */
 function every(map, predicate) {
 	for (const [key, value] of map) if (!predicate(value, key)) return false;
@@ -58,7 +58,7 @@ function every(map, predicate) {
 * @example
 * filter(new Map([['a', 1], ['b', 2], ['c', 3]]), value => value % 2 === 0)
 * // => Map(1) { 'b' => 2 }
-* @since next
+* @since 3.0.3
 */
 function filter(map, predicate) {
 	const result = /* @__PURE__ */ new Map();
@@ -80,7 +80,7 @@ function filter(map, predicate) {
 * @example
 * findKey(new Map([['a', 1], ['b', 2]]), value => value > 1)
 * // => 'b'
-* @since next
+* @since 3.0.3
 */
 function findKey(map, predicate) {
 	for (const [key, value] of map) if (predicate(value, key)) return key;
@@ -100,7 +100,7 @@ function findKey(map, predicate) {
 * @example
 * findValue(new Map([['a', 1], ['b', 2]]), value => value > 1)
 * // => 2
-* @since next
+* @since 3.0.3
 */
 function findValue(map, predicate) {
 	for (const [key, value] of map) if (predicate(value, key)) return value;
@@ -121,7 +121,7 @@ function findValue(map, predicate) {
 * @example
 * hasValue(new Map([['a', 1], ['b', 2]]), 2)
 * // => true
-* @since next
+* @since 3.0.3
 */
 function hasValue(map, value) {
 	for (const v of map.values()) if (Object.is(v, value)) return true;
@@ -143,7 +143,7 @@ function hasValue(map, value) {
 * @example
 * mapKeys(new Map([['a', 1], ['b', 2]]), key => key.toUpperCase())
 * // => Map(2) { 'A' => 1, 'B' => 2 }
-* @since next
+* @since 3.0.3
 */
 function mapKeys(map, fn) {
 	const result = /* @__PURE__ */ new Map();
@@ -165,7 +165,7 @@ function mapKeys(map, fn) {
 * @example
 * mapValues(new Map([['a', 1], ['b', 2]]), value => value * 10)
 * // => Map(2) { 'a' => 10, 'b' => 20 }
-* @since next
+* @since 3.0.3
 */
 function mapValues(map, fn) {
 	const result = /* @__PURE__ */ new Map();
@@ -188,7 +188,7 @@ function mapValues(map, fn) {
 * @example
 * reduce(new Map([['a', 1], ['b', 2]]), (acc, value) => acc + value, 0)
 * // => 3
-* @since next
+* @since 3.0.3
 */
 function reduce(map, fn, initial) {
 	let accumulator = initial;
@@ -210,7 +210,7 @@ function reduce(map, fn, initial) {
 * @example
 * some(new Map([['a', 1], ['b', 2]]), value => value > 1)
 * // => true
-* @since next
+* @since 3.0.3
 */
 function some(map, predicate) {
 	for (const [key, value] of map) if (predicate(value, key)) return true;
@@ -236,7 +236,7 @@ function some(map, predicate) {
 * @example
 * toMapByKey([{ id: 'a', n: 1 }, { id: 'b', n: 2 }], item => item.id)
 * // => Map(2) { 'a' => { id: 'a', n: 1 }, 'b' => { id: 'b', n: 2 } }
-* @since next
+* @since 3.0.3
 */
 function toMapByKey(items, fn) {
 	const result = /* @__PURE__ */ new Map();

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../helpers/map/countBy.ts","../../../helpers/map/every.ts","../../../helpers/map/filter.ts","../../../helpers/map/findKey.ts","../../../helpers/map/findValue.ts","../../../helpers/map/hasValue.ts","../../../helpers/map/mapKeys.ts","../../../helpers/map/mapValues.ts","../../../helpers/map/reduce.ts","../../../helpers/map/some.ts","../../../helpers/map/toMapByKey.ts"],"sourcesContent":["/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Groups the entries of a Map by a derived key and counts how many fall into each group.\n * @param map - The Map to summarize\n * @param fn - Function deriving the grouping key from (value, key)\n * @returns A Map from derived key to the number of entries in that group\n * @example\n * countBy(new Map([['a', 1], ['b', 2], ['c', 3]]), value => value % 2 === 0 ? 'even' : 'odd')\n * // => Map(2) { 'odd' => 2, 'even' => 1 }\n * @since next\n */\nexport function countBy<K, V, R>(\n  map: ReadonlyMap<K, V>,\n  fn: (value: V, key: K) => R,\n): Map<R, number> {\n  const counts = new Map<R, number>();\n  for (const [key, value] of map) {\n    const group = fn(value, key);\n    counts.set(group, (counts.get(group) ?? 0) + 1);\n  }\n  return counts;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if every entry of a Map satisfies the predicate. Short-circuits on the first mismatch.\n * @param map - The Map to check\n * @param predicate - Function invoked with (value, key)\n * @returns `true` if all entries match (vacuously `true` for an empty map), `false` otherwise\n * @example\n * every(new Map([['a', 1], ['b', 2]]), value => value > 0)\n * // => true\n * @since next\n */\nexport function every<K, V>(\n  map: ReadonlyMap<K, V>,\n  predicate: (value: V, key: K) => boolean,\n): boolean {\n  for (const [key, value] of map) {\n    if (!predicate(value, key)) return false;\n  }\n  return true;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Creates a new Map containing only the entries for which the predicate returns true.\n * @param map - The Map to filter\n * @param predicate - Function invoked with (value, key) — return true to keep the entry\n * @returns A new Map with only the matching entries\n * @example\n * filter(new Map([['a', 1], ['b', 2], ['c', 3]]), value => value % 2 === 0)\n * // => Map(1) { 'b' => 2 }\n * @since next\n */\nexport function filter<K, V>(\n  map: ReadonlyMap<K, V>,\n  predicate: (value: V, key: K) => boolean,\n): Map<K, V> {\n  const result = new Map<K, V>();\n  for (const [key, value] of map) {\n    if (predicate(value, key)) {\n      result.set(key, value);\n    }\n  }\n  return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Returns the first key of a Map whose entry satisfies the predicate, in insertion order.\n * @param map - The Map to search\n * @param predicate - Function invoked with (value, key)\n * @returns The matching key, or `undefined` if none matches\n * @example\n * findKey(new Map([['a', 1], ['b', 2]]), value => value > 1)\n * // => 'b'\n * @since next\n */\nexport function findKey<K, V>(\n  map: ReadonlyMap<K, V>,\n  predicate: (value: V, key: K) => boolean,\n): K | undefined {\n  for (const [key, value] of map) {\n    if (predicate(value, key)) return key;\n  }\n  return undefined;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Returns the first value of a Map whose entry satisfies the predicate, in insertion order.\n * @param map - The Map to search\n * @param predicate - Function invoked with (value, key)\n * @returns The matching value, or `undefined` if none matches\n * @example\n * findValue(new Map([['a', 1], ['b', 2]]), value => value > 1)\n * // => 2\n * @since next\n */\nexport function findValue<K, V>(\n  map: ReadonlyMap<K, V>,\n  predicate: (value: V, key: K) => boolean,\n): V | undefined {\n  for (const [key, value] of map) {\n    if (predicate(value, key)) return value;\n  }\n  return undefined;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks whether a value exists anywhere in a Map (`Map.prototype.has` checks keys, not values).\n * Uses `Object.is`-style equality (via `===`, with `NaN` matching `NaN`).\n * @param map - The Map to search\n * @param value - The value to look for\n * @returns `true` if the value is found in at least one entry\n * @example\n * hasValue(new Map([['a', 1], ['b', 2]]), 2)\n * // => true\n * @since next\n */\nexport function hasValue<K, V>(map: ReadonlyMap<K, V>, value: V): boolean {\n  for (const v of map.values()) {\n    if (Object.is(v, value)) return true;\n  }\n  return false;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Creates a new Map with the same values but with each key transformed by a function.\n * If two entries derive the same new key, the later one (in insertion order) wins.\n * @param map - The Map to transform\n * @param fn - Function invoked with (key, value) that returns the new key\n * @returns A new Map with transformed keys\n * @example\n * mapKeys(new Map([['a', 1], ['b', 2]]), key => key.toUpperCase())\n * // => Map(2) { 'A' => 1, 'B' => 2 }\n * @since next\n */\nexport function mapKeys<K, V, R>(\n  map: ReadonlyMap<K, V>,\n  fn: (key: K, value: V) => R,\n): Map<R, V> {\n  const result = new Map<R, V>();\n  for (const [key, value] of map) {\n    result.set(fn(key, value), value);\n  }\n  return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Creates a new Map with the same keys but with each value transformed by a function.\n * @param map - The Map to transform\n * @param fn - Function invoked with (value, key) that returns the new value\n * @returns A new Map with transformed values\n * @example\n * mapValues(new Map([['a', 1], ['b', 2]]), value => value * 10)\n * // => Map(2) { 'a' => 10, 'b' => 20 }\n * @since next\n */\nexport function mapValues<K, V, R>(\n  map: ReadonlyMap<K, V>,\n  fn: (value: V, key: K) => R,\n): Map<K, R> {\n  const result = new Map<K, R>();\n  for (const [key, value] of map) {\n    result.set(key, fn(value, key));\n  }\n  return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Reduces a Map to a single value by applying a function to each entry, in insertion order.\n * @param map - The Map to reduce\n * @param fn - Function invoked with (accumulator, value, key)\n * @param initial - Initial accumulator value\n * @returns The final accumulator value\n * @example\n * reduce(new Map([['a', 1], ['b', 2]]), (acc, value) => acc + value, 0)\n * // => 3\n * @since next\n */\nexport function reduce<K, V, R>(\n  map: ReadonlyMap<K, V>,\n  fn: (accumulator: R, value: V, key: K) => R,\n  initial: R,\n): R {\n  let accumulator = initial;\n  for (const [key, value] of map) {\n    accumulator = fn(accumulator, value, key);\n  }\n  return accumulator;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if at least one entry of a Map satisfies the predicate. Short-circuits on the first match.\n * @param map - The Map to check\n * @param predicate - Function invoked with (value, key)\n * @returns `true` if at least one entry matches, `false` otherwise (including for an empty map)\n * @example\n * some(new Map([['a', 1], ['b', 2]]), value => value > 1)\n * // => true\n * @since next\n */\nexport function some<K, V>(\n  map: ReadonlyMap<K, V>,\n  predicate: (value: V, key: K) => boolean,\n): boolean {\n  for (const [key, value] of map) {\n    if (predicate(value, key)) return true;\n  }\n  return false;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Builds a Map from an iterable of items, keyed by a derived key. When two items derive the\n * same key, the later item wins (last-write-wins, matching `Map.prototype.set` semantics).\n *\n * Named `toMapByKey`, not `keyBy` (lodash's name for the same idea) — lodash's `_.keyBy`\n * returns a plain object, not a `Map`; the `to<Type>` prefix (matching `toSorted`/`toReversed`)\n * makes the actual return type unambiguous.\n * @param items - The items to index\n * @param fn - Function deriving the key for each item\n * @returns A Map from derived key to item\n * @example\n * toMapByKey([{ id: 'a', n: 1 }, { id: 'b', n: 2 }], item => item.id)\n * // => Map(2) { 'a' => { id: 'a', n: 1 }, 'b' => { id: 'b', n: 2 } }\n * @since next\n */\nexport function toMapByKey<T, K>(items: Iterable<T>, fn: (item: T) => K): Map<K, T> {\n  const result = new Map<K, T>();\n  for (const item of items) {\n    result.set(fn(item), item);\n  }\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,SAAgB,QACd,KACA,IACgB;CAChB,MAAM,yBAAS,IAAI,IAAe;CAClC,KAAK,MAAM,CAAC,KAAK,UAAU,KAAK;EAC9B,MAAM,QAAQ,GAAG,OAAO,GAAG;EAC3B,OAAO,IAAI,QAAQ,OAAO,IAAI,KAAK,KAAK,KAAK,CAAC;CAChD;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;ACVA,SAAgB,MACd,KACA,WACS;CACT,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,IAAI,CAAC,UAAU,OAAO,GAAG,GAAG,OAAO;CAErC,OAAO;AACT;;;;;;;;;;;;;;;;;;ACRA,SAAgB,OACd,KACA,WACW;CACX,MAAM,yBAAS,IAAI,IAAU;CAC7B,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,IAAI,UAAU,OAAO,GAAG,GACtB,OAAO,IAAI,KAAK,KAAK;CAGzB,OAAO;AACT;;;;;;;;;;;;;;;;;;ACXA,SAAgB,QACd,KACA,WACe;CACf,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,IAAI,UAAU,OAAO,GAAG,GAAG,OAAO;AAGtC;;;;;;;;;;;;;;;;;;ACRA,SAAgB,UACd,KACA,WACe;CACf,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,IAAI,UAAU,OAAO,GAAG,GAAG,OAAO;AAGtC;;;;;;;;;;;;;;;;;;;ACPA,SAAgB,SAAe,KAAwB,OAAmB;CACxE,KAAK,MAAM,KAAK,IAAI,OAAO,GACzB,IAAI,OAAO,GAAG,GAAG,KAAK,GAAG,OAAO;CAElC,OAAO;AACT;;;;;;;;;;;;;;;;;;;ACLA,SAAgB,QACd,KACA,IACW;CACX,MAAM,yBAAS,IAAI,IAAU;CAC7B,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,OAAO,IAAI,GAAG,KAAK,KAAK,GAAG,KAAK;CAElC,OAAO;AACT;;;;;;;;;;;;;;;;;;ACVA,SAAgB,UACd,KACA,IACW;CACX,MAAM,yBAAS,IAAI,IAAU;CAC7B,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,OAAO,IAAI,KAAK,GAAG,OAAO,GAAG,CAAC;CAEhC,OAAO;AACT;;;;;;;;;;;;;;;;;;;ACRA,SAAgB,OACd,KACA,IACA,SACG;CACH,IAAI,cAAc;CAClB,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,cAAc,GAAG,aAAa,OAAO,GAAG;CAE1C,OAAO;AACT;;;;;;;;;;;;;;;;;;ACXA,SAAgB,KACd,KACA,WACS;CACT,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,IAAI,UAAU,OAAO,GAAG,GAAG,OAAO;CAEpC,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;ACHA,SAAgB,WAAiB,OAAoB,IAA+B;CAClF,MAAM,yBAAS,IAAI,IAAU;CAC7B,KAAK,MAAM,QAAQ,OACjB,OAAO,IAAI,GAAG,IAAI,GAAG,IAAI;CAE3B,OAAO;AACT"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../helpers/map/countBy.ts","../../../helpers/map/every.ts","../../../helpers/map/filter.ts","../../../helpers/map/findKey.ts","../../../helpers/map/findValue.ts","../../../helpers/map/hasValue.ts","../../../helpers/map/mapKeys.ts","../../../helpers/map/mapValues.ts","../../../helpers/map/reduce.ts","../../../helpers/map/some.ts","../../../helpers/map/toMapByKey.ts"],"sourcesContent":["/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Groups the entries of a Map by a derived key and counts how many fall into each group.\n * @param map - The Map to summarize\n * @param fn - Function deriving the grouping key from (value, key)\n * @returns A Map from derived key to the number of entries in that group\n * @example\n * countBy(new Map([['a', 1], ['b', 2], ['c', 3]]), value => value % 2 === 0 ? 'even' : 'odd')\n * // => Map(2) { 'odd' => 2, 'even' => 1 }\n * @since 3.0.3\n */\nexport function countBy<K, V, R>(\n  map: ReadonlyMap<K, V>,\n  fn: (value: V, key: K) => R,\n): Map<R, number> {\n  const counts = new Map<R, number>();\n  for (const [key, value] of map) {\n    const group = fn(value, key);\n    counts.set(group, (counts.get(group) ?? 0) + 1);\n  }\n  return counts;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if every entry of a Map satisfies the predicate. Short-circuits on the first mismatch.\n * @param map - The Map to check\n * @param predicate - Function invoked with (value, key)\n * @returns `true` if all entries match (vacuously `true` for an empty map), `false` otherwise\n * @example\n * every(new Map([['a', 1], ['b', 2]]), value => value > 0)\n * // => true\n * @since 3.0.3\n */\nexport function every<K, V>(\n  map: ReadonlyMap<K, V>,\n  predicate: (value: V, key: K) => boolean,\n): boolean {\n  for (const [key, value] of map) {\n    if (!predicate(value, key)) return false;\n  }\n  return true;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Creates a new Map containing only the entries for which the predicate returns true.\n * @param map - The Map to filter\n * @param predicate - Function invoked with (value, key) — return true to keep the entry\n * @returns A new Map with only the matching entries\n * @example\n * filter(new Map([['a', 1], ['b', 2], ['c', 3]]), value => value % 2 === 0)\n * // => Map(1) { 'b' => 2 }\n * @since 3.0.3\n */\nexport function filter<K, V>(\n  map: ReadonlyMap<K, V>,\n  predicate: (value: V, key: K) => boolean,\n): Map<K, V> {\n  const result = new Map<K, V>();\n  for (const [key, value] of map) {\n    if (predicate(value, key)) {\n      result.set(key, value);\n    }\n  }\n  return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Returns the first key of a Map whose entry satisfies the predicate, in insertion order.\n * @param map - The Map to search\n * @param predicate - Function invoked with (value, key)\n * @returns The matching key, or `undefined` if none matches\n * @example\n * findKey(new Map([['a', 1], ['b', 2]]), value => value > 1)\n * // => 'b'\n * @since 3.0.3\n */\nexport function findKey<K, V>(\n  map: ReadonlyMap<K, V>,\n  predicate: (value: V, key: K) => boolean,\n): K | undefined {\n  for (const [key, value] of map) {\n    if (predicate(value, key)) return key;\n  }\n  return undefined;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Returns the first value of a Map whose entry satisfies the predicate, in insertion order.\n * @param map - The Map to search\n * @param predicate - Function invoked with (value, key)\n * @returns The matching value, or `undefined` if none matches\n * @example\n * findValue(new Map([['a', 1], ['b', 2]]), value => value > 1)\n * // => 2\n * @since 3.0.3\n */\nexport function findValue<K, V>(\n  map: ReadonlyMap<K, V>,\n  predicate: (value: V, key: K) => boolean,\n): V | undefined {\n  for (const [key, value] of map) {\n    if (predicate(value, key)) return value;\n  }\n  return undefined;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks whether a value exists anywhere in a Map (`Map.prototype.has` checks keys, not values).\n * Uses `Object.is`-style equality (via `===`, with `NaN` matching `NaN`).\n * @param map - The Map to search\n * @param value - The value to look for\n * @returns `true` if the value is found in at least one entry\n * @example\n * hasValue(new Map([['a', 1], ['b', 2]]), 2)\n * // => true\n * @since 3.0.3\n */\nexport function hasValue<K, V>(map: ReadonlyMap<K, V>, value: V): boolean {\n  for (const v of map.values()) {\n    if (Object.is(v, value)) return true;\n  }\n  return false;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Creates a new Map with the same values but with each key transformed by a function.\n * If two entries derive the same new key, the later one (in insertion order) wins.\n * @param map - The Map to transform\n * @param fn - Function invoked with (key, value) that returns the new key\n * @returns A new Map with transformed keys\n * @example\n * mapKeys(new Map([['a', 1], ['b', 2]]), key => key.toUpperCase())\n * // => Map(2) { 'A' => 1, 'B' => 2 }\n * @since 3.0.3\n */\nexport function mapKeys<K, V, R>(\n  map: ReadonlyMap<K, V>,\n  fn: (key: K, value: V) => R,\n): Map<R, V> {\n  const result = new Map<R, V>();\n  for (const [key, value] of map) {\n    result.set(fn(key, value), value);\n  }\n  return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Creates a new Map with the same keys but with each value transformed by a function.\n * @param map - The Map to transform\n * @param fn - Function invoked with (value, key) that returns the new value\n * @returns A new Map with transformed values\n * @example\n * mapValues(new Map([['a', 1], ['b', 2]]), value => value * 10)\n * // => Map(2) { 'a' => 10, 'b' => 20 }\n * @since 3.0.3\n */\nexport function mapValues<K, V, R>(\n  map: ReadonlyMap<K, V>,\n  fn: (value: V, key: K) => R,\n): Map<K, R> {\n  const result = new Map<K, R>();\n  for (const [key, value] of map) {\n    result.set(key, fn(value, key));\n  }\n  return result;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Reduces a Map to a single value by applying a function to each entry, in insertion order.\n * @param map - The Map to reduce\n * @param fn - Function invoked with (accumulator, value, key)\n * @param initial - Initial accumulator value\n * @returns The final accumulator value\n * @example\n * reduce(new Map([['a', 1], ['b', 2]]), (acc, value) => acc + value, 0)\n * // => 3\n * @since 3.0.3\n */\nexport function reduce<K, V, R>(\n  map: ReadonlyMap<K, V>,\n  fn: (accumulator: R, value: V, key: K) => R,\n  initial: R,\n): R {\n  let accumulator = initial;\n  for (const [key, value] of map) {\n    accumulator = fn(accumulator, value, key);\n  }\n  return accumulator;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Checks if at least one entry of a Map satisfies the predicate. Short-circuits on the first match.\n * @param map - The Map to check\n * @param predicate - Function invoked with (value, key)\n * @returns `true` if at least one entry matches, `false` otherwise (including for an empty map)\n * @example\n * some(new Map([['a', 1], ['b', 2]]), value => value > 1)\n * // => true\n * @since 3.0.3\n */\nexport function some<K, V>(\n  map: ReadonlyMap<K, V>,\n  predicate: (value: V, key: K) => boolean,\n): boolean {\n  for (const [key, value] of map) {\n    if (predicate(value, key)) return true;\n  }\n  return false;\n}\n","/**\n * This file is part of helpers4.\n * Copyright (C) 2025 baxyz\n * SPDX-License-Identifier: LGPL-3.0-or-later\n */\n\n/**\n * Builds a Map from an iterable of items, keyed by a derived key. When two items derive the\n * same key, the later item wins (last-write-wins, matching `Map.prototype.set` semantics).\n *\n * Named `toMapByKey`, not `keyBy` (lodash's name for the same idea) — lodash's `_.keyBy`\n * returns a plain object, not a `Map`; the `to<Type>` prefix (matching `toSorted`/`toReversed`)\n * makes the actual return type unambiguous.\n * @param items - The items to index\n * @param fn - Function deriving the key for each item\n * @returns A Map from derived key to item\n * @example\n * toMapByKey([{ id: 'a', n: 1 }, { id: 'b', n: 2 }], item => item.id)\n * // => Map(2) { 'a' => { id: 'a', n: 1 }, 'b' => { id: 'b', n: 2 } }\n * @since 3.0.3\n */\nexport function toMapByKey<T, K>(items: Iterable<T>, fn: (item: T) => K): Map<K, T> {\n  const result = new Map<K, T>();\n  for (const item of items) {\n    result.set(fn(item), item);\n  }\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,SAAgB,QACd,KACA,IACgB;CAChB,MAAM,yBAAS,IAAI,IAAe;CAClC,KAAK,MAAM,CAAC,KAAK,UAAU,KAAK;EAC9B,MAAM,QAAQ,GAAG,OAAO,GAAG;EAC3B,OAAO,IAAI,QAAQ,OAAO,IAAI,KAAK,KAAK,KAAK,CAAC;CAChD;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;ACVA,SAAgB,MACd,KACA,WACS;CACT,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,IAAI,CAAC,UAAU,OAAO,GAAG,GAAG,OAAO;CAErC,OAAO;AACT;;;;;;;;;;;;;;;;;;ACRA,SAAgB,OACd,KACA,WACW;CACX,MAAM,yBAAS,IAAI,IAAU;CAC7B,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,IAAI,UAAU,OAAO,GAAG,GACtB,OAAO,IAAI,KAAK,KAAK;CAGzB,OAAO;AACT;;;;;;;;;;;;;;;;;;ACXA,SAAgB,QACd,KACA,WACe;CACf,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,IAAI,UAAU,OAAO,GAAG,GAAG,OAAO;AAGtC;;;;;;;;;;;;;;;;;;ACRA,SAAgB,UACd,KACA,WACe;CACf,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,IAAI,UAAU,OAAO,GAAG,GAAG,OAAO;AAGtC;;;;;;;;;;;;;;;;;;;ACPA,SAAgB,SAAe,KAAwB,OAAmB;CACxE,KAAK,MAAM,KAAK,IAAI,OAAO,GACzB,IAAI,OAAO,GAAG,GAAG,KAAK,GAAG,OAAO;CAElC,OAAO;AACT;;;;;;;;;;;;;;;;;;;ACLA,SAAgB,QACd,KACA,IACW;CACX,MAAM,yBAAS,IAAI,IAAU;CAC7B,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,OAAO,IAAI,GAAG,KAAK,KAAK,GAAG,KAAK;CAElC,OAAO;AACT;;;;;;;;;;;;;;;;;;ACVA,SAAgB,UACd,KACA,IACW;CACX,MAAM,yBAAS,IAAI,IAAU;CAC7B,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,OAAO,IAAI,KAAK,GAAG,OAAO,GAAG,CAAC;CAEhC,OAAO;AACT;;;;;;;;;;;;;;;;;;;ACRA,SAAgB,OACd,KACA,IACA,SACG;CACH,IAAI,cAAc;CAClB,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,cAAc,GAAG,aAAa,OAAO,GAAG;CAE1C,OAAO;AACT;;;;;;;;;;;;;;;;;;ACXA,SAAgB,KACd,KACA,WACS;CACT,KAAK,MAAM,CAAC,KAAK,UAAU,KACzB,IAAI,UAAU,OAAO,GAAG,GAAG,OAAO;CAEpC,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;ACHA,SAAgB,WAAiB,OAAoB,IAA+B;CAClF,MAAM,yBAAS,IAAI,IAAU;CAC7B,KAAK,MAAM,QAAQ,OACjB,OAAO,IAAI,GAAG,IAAI,GAAG,IAAI;CAE3B,OAAO;AACT"}

package/llms.txt

@@ -1,7 +1,7 @@
 # @helpers4/map
 
 > Tree-shakable TypeScript utility functions for the `map` domain.
-> Package: `@helpers4/map` — Version: 3.0.2
+> Package: `@helpers4/map` — Version: 3.0.4
 > License: LGPL-3.0-or-later
 
 ## Installation

package/meta/api.json

@@ -1,12 +1,12 @@
 {
   "category": "map",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "functions": [
     {
       "name": "countBy",
       "kind": "function",
       "description": "Groups the entries of a Map by a derived key and counts how many fall into each group.",
-      "since": "next",
+      "since": "3.0.3",
       "signatures": [
         {
           "signature": "countBy<K, V, R>(map: ReadonlyMap<K, V>, fn: function): Map<R, number>",
@@ -53,7 +53,7 @@
       "name": "every",
       "kind": "function",
       "description": "Checks if every entry of a Map satisfies the predicate. Short-circuits on the first mismatch.",
-      "since": "next",
+      "since": "3.0.3",
       "signatures": [
         {
           "signature": "every<K, V>(map: ReadonlyMap<K, V>, predicate: function): boolean",
@@ -102,7 +102,7 @@
       "name": "filter",
       "kind": "function",
       "description": "Creates a new Map containing only the entries for which the predicate returns true.",
-      "since": "next",
+      "since": "3.0.3",
       "signatures": [
         {
           "signature": "filter<K, V>(map: ReadonlyMap<K, V>, predicate: function): Map<K, V>",
@@ -151,7 +151,7 @@
       "name": "findKey",
       "kind": "function",
       "description": "Returns the first key of a Map whose entry satisfies the predicate, in insertion order.",
-      "since": "next",
+      "since": "3.0.3",
       "signatures": [
         {
           "signature": "findKey<K, V>(map: ReadonlyMap<K, V>, predicate: function): K | undefined",
@@ -200,7 +200,7 @@
       "name": "findValue",
       "kind": "function",
       "description": "Returns the first value of a Map whose entry satisfies the predicate, in insertion order.",
-      "since": "next",
+      "since": "3.0.3",
       "signatures": [
         {
           "signature": "findValue<K, V>(map: ReadonlyMap<K, V>, predicate: function): V | undefined",
@@ -249,7 +249,7 @@
       "name": "hasValue",
       "kind": "function",
       "description": "Checks whether a value exists anywhere in a Map (`Map.prototype.has` checks keys, not values).\nUses `Object.is`-style equality (via `===`, with `NaN` matching `NaN`).",
-      "since": "next",
+      "since": "3.0.3",
       "signatures": [
         {
           "signature": "hasValue<K, V>(map: ReadonlyMap<K, V>, value: V): boolean",
@@ -298,7 +298,7 @@
       "name": "mapKeys",
       "kind": "function",
       "description": "Creates a new Map with the same values but with each key transformed by a function.\nIf two entries derive the same new key, the later one (in insertion order) wins.",
-      "since": "next",
+      "since": "3.0.3",
       "signatures": [
         {
           "signature": "mapKeys<K, V, R>(map: ReadonlyMap<K, V>, fn: function): Map<R, V>",
@@ -345,7 +345,7 @@
       "name": "mapValues",
       "kind": "function",
       "description": "Creates a new Map with the same keys but with each value transformed by a function.",
-      "since": "next",
+      "since": "3.0.3",
       "signatures": [
         {
           "signature": "mapValues<K, V, R>(map: ReadonlyMap<K, V>, fn: function): Map<K, R>",
@@ -392,7 +392,7 @@
       "name": "reduce",
       "kind": "function",
       "description": "Reduces a Map to a single value by applying a function to each entry, in insertion order.",
-      "since": "next",
+      "since": "3.0.3",
       "signatures": [
         {
           "signature": "reduce<K, V, R>(map: ReadonlyMap<K, V>, fn: function, initial: R): R",
@@ -449,7 +449,7 @@
       "name": "some",
       "kind": "function",
       "description": "Checks if at least one entry of a Map satisfies the predicate. Short-circuits on the first match.",
-      "since": "next",
+      "since": "3.0.3",
       "signatures": [
         {
           "signature": "some<K, V>(map: ReadonlyMap<K, V>, predicate: function): boolean",
@@ -498,7 +498,7 @@
       "name": "toMapByKey",
       "kind": "function",
       "description": "Builds a Map from an iterable of items, keyed by a derived key. When two items derive the\nsame key, the later item wins (last-write-wins, matching `Map.prototype.set` semantics).\n\nNamed `toMapByKey`, not `keyBy` (lodash's name for the same idea) — lodash's `_.keyBy`\nreturns a plain object, not a `Map`; the `to<Type>` prefix (matching `toSorted`/`toReversed`)\nmakes the actual return type unambiguous.",
-      "since": "next",
+      "since": "3.0.3",
       "signatures": [
         {
           "signature": "toMapByKey<T, K>(items: Iterable<T>, fn: function): Map<K, T>",

package/meta/native-alternatives.json

@@ -38,7 +38,7 @@
       "notes": "Thin wrapper for readability — Map.prototype.has() checks keys, not values, which is the actual reason this needs its own name."
     },
     {
-      "name": "countBy / keyBy",
+      "name": "groupBy",
       "libraries": [
         "es-toolkit"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helpers4/map",
-  "version": "3.0.2-alpha.0",
+  "version": "3.0.4",
   "description": "A set of helpers in TS/JS, compatible with tree-shaking, for map.",
   "author": "baxyz <baxy@etik.com>",
   "license": "LGPL-3.0",
@@ -52,4 +52,4 @@
   "engines": {
     "node": ">=26.0.0"
   }
-}
+}