ts-data-forge 9.0.0 → 10.0.0

package/dist/collections/iset-mapped.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"iset-mapped.mjs","sources":["../../src/collections/iset-mapped.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"iset-mapped.mjs","sources":["../../src/collections/iset-mapped.mts"],"sourcesContent":["/* eslint-disable unicorn/prefer-iterator-to-array-at-end */\nimport { type ReadonlyRecord, type WidenLiteral } from 'ts-type-forge';\nimport { asUint32 } from '../number/index.mjs';\nimport { type MapSetKeyType, type SizeType } from '../types.mjs';\n\n/**\n * Interface for an immutable set with custom element mapping and membership\n * testing.\n *\n * ISetMapped allows you to use complex objects as set elements by providing\n * transformation functions that convert between your custom element type `K`\n * and a primitive `MapSetKeyType` `KM` that can be efficiently stored in\n * JavaScript's native Set. This enables set operations on complex elements\n * while maintaining type safety and immutability.\n *\n * **Key Features:**\n *\n * - **Custom Element Types**: Use any type as set elements by providing\n *   `toKey`/`fromKey` functions\n * - **Immutable**: All operations return new instances, preserving immutability\n * - **Set Operations**: Full support for union, intersection, difference,\n *   subset/superset checks\n * - **Type Safe**: Full TypeScript support with generic element types\n *\n * **Performance Characteristics:**\n *\n * - has: O(1) average case (plus element transformation overhead)\n * - add/delete: O(n) due to copying for immutability (plus element\n *   transformation overhead)\n * - set operations (union, intersection, difference): O(n)\n * - map/filter operations: O(n)\n * - iteration: O(n) (plus element transformation overhead)\n *\n * @template K The type of the custom elements in the set.\n * @template KM The type of the mapped primitive keys (string, number, etc.).\n */\ntype ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{\n  /**\n   * Creates a new ISetMapped instance.\n   *\n   * @param iterable An iterable of elements.\n   * @param toKey A function that converts an element of type `K` to `KM`.\n   * @param fromKey A function that converts a mapped key of type `KM` back to\n   *   `K`.\n   */\n  new (iterable: Iterable<K>, toKey: (a: K) => KM, fromKey: (k: KM) => K): void;\n\n  // Getting information\n\n  /**\n   * The number of elements in the set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const points: readonly Point[] = [\n   *   { x: 1, tag: 'a' },\n   *   { x: 2, tag: 'b' },\n   * ] as const;\n   *\n   * const set = ISetMapped.create<Point, string>(points, toKey, fromKey);\n   *\n   * assert.isTrue(set.size === 2);\n   * ```\n   */\n  size: SizeType.Arr;\n\n  /**\n   * Checks if the set is empty.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const empty = ISetMapped.create<Point, string>([], toKey, fromKey);\n   *\n   * const points = ISetMapped.create<Point, string>(\n   *   [{ x: 1, tag: 'a' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.isTrue(empty.isEmpty);\n   *\n   * assert.isFalse(points.isEmpty);\n   * ```\n   */\n  isEmpty: boolean;\n\n  /**\n   * Checks if an element exists in the set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [{ x: 1, tag: 'a' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.isTrue(set.has({ x: 1, tag: 'a' }));\n   *\n   * assert.isFalse(set.has({ x: 2, tag: 'b' }));\n   * ```\n   *\n   * @param key The element to check.\n   * @returns `true` if the element exists, `false` otherwise.\n   */\n  has: (key: K | (WidenLiteral<K> & {})) => boolean;\n\n  // Reducing a value\n\n  /**\n   * Checks if all elements in the set satisfy a type predicate. Narrows the\n   * type of elements in the set if the predicate returns true for all\n   * elements.\n   *\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 2, tag: 'even' },\n   *     { x: 4, tag: 'even' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const allEven = set.every((point) => point.x % 2 === 0);\n   *\n   * const narrowed = set.every(\n   *   (point): point is Readonly<{ x: 2 | 4; tag: 'even' }> =>\n   *     point.x % 2 === 0,\n   * );\n   *\n   * assert.isTrue(allEven);\n   *\n   * assert.isTrue(narrowed);\n   * ```\n   *\n   * @template L The narrowed type of the elements.\n   * @param predicate A function to test each element.\n   * @returns `true` if all elements satisfy the predicate, `false` otherwise.\n   */\n  every: ((predicate: (key: K) => boolean) => boolean) &\n    (<L extends K>(\n      predicate: (key: K) => key is L,\n    ) => this is ISetMapped<L, KM>);\n\n  /**\n   * Checks if at least one element in the set satisfies a predicate.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 5, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.isTrue(set.some((point) => point.x > 4));\n   *\n   * assert.isFalse(set.some((point) => point.x > 10));\n   * ```\n   *\n   * @param predicate A function to test each element.\n   * @returns `true` if at least one element satisfies the predicate, `false`\n   *   otherwise.\n   */\n  some: (predicate: (key: K) => boolean) => boolean;\n\n  // Mutation\n\n  /**\n   * Adds an element to the set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const base = ISetMapped.create<Point, string>(\n   *   [{ x: 1, tag: 'a' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const withNew = base.add({ x: 2, tag: 'b' });\n   *\n   * const unchanged = base.add({ x: 1, tag: 'a' });\n   *\n   * assert.deepStrictEqual(Array.from(withNew), [\n   *   { x: 1, tag: 'a' },\n   *   { x: 2, tag: 'b' },\n   * ]);\n   *\n   * assert.isTrue(unchanged === base);\n   * ```\n   *\n   * @param key The element to add.\n   * @returns A new ISetMapped instance with the element added.\n   */\n  add: (key: K) => ISetMapped<K, KM>;\n\n  /**\n   * Deletes an element from the set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const base = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const withoutSecond = base.delete({ x: 2, tag: 'b' });\n   *\n   * const unchanged = base.delete({ x: 3, tag: 'c' });\n   *\n   * assert.deepStrictEqual(Array.from(withoutSecond), [{ x: 1, tag: 'a' }]);\n   *\n   * assert.isTrue(unchanged === base);\n   * ```\n   *\n   * @param key The element to delete.\n   * @returns A new ISetMapped instance without the specified element.\n   */\n  delete: (key: K) => ISetMapped<K, KM>;\n\n  /**\n   * Applies a series of mutations to the set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const base = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const actions: readonly Readonly<\n   *   { type: 'add'; key: Point } | { type: 'delete'; key: Point }\n   * >[] = [\n   *   { type: 'add', key: { x: 3, tag: 'c' } },\n   *   { type: 'delete', key: { x: 1, tag: 'a' } },\n   * ] as const;\n   *\n   * const mutated = base.withMutations(actions);\n   *\n   * assert.deepStrictEqual(Array.from(mutated), [\n   *   { x: 2, tag: 'b' },\n   *   { x: 3, tag: 'c' },\n   * ]);\n   *\n   * assert.deepStrictEqual(Array.from(base), [\n   *   { x: 1, tag: 'a' },\n   *   { x: 2, tag: 'b' },\n   * ]);\n   * ```\n   *\n   * @param actions An array of mutation actions (add or delete).\n   * @returns A new ISetMapped instance with all mutations applied.\n   */\n  withMutations: (\n    actions: readonly Readonly<\n      { type: 'add'; key: K } | { type: 'delete'; key: K }\n    >[],\n  ) => ISetMapped<K, KM>;\n\n  // Sequence algorithms\n\n  /**\n   * Maps the elements of the set to new elements. Note: The element type `K`\n   * cannot be changed because `toKey` and `fromKey` would become unusable if\n   * the mapped type `KM` changes.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const shifted = set.map((point) => ({\n   *   x: point.x + 10,\n   *   tag: point.tag.toUpperCase(),\n   * }));\n   *\n   * assert.deepStrictEqual(Array.from(shifted), [\n   *   { x: 11, tag: 'A' },\n   *   { x: 12, tag: 'B' },\n   * ]);\n   * ```\n   *\n   * @param mapFn A function that maps an element to a new element of the same\n   *   type `K`.\n   * @returns A new ISetMapped instance with mapped elements.\n   */\n  map: (mapFn: (key: K) => K) => ISetMapped<K, KM>;\n\n  /**\n   * Filters the elements of the set based on a predicate.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *     { x: 3, tag: 'c' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const evenPoints = set.filter((point) => point.x % 2 === 0);\n   *\n   * assert.deepStrictEqual(Array.from(evenPoints), [{ x: 2, tag: 'b' }]);\n   * ```\n   *\n   * @param predicate A function to test each element.\n   * @returns A new ISetMapped instance with elements that satisfy the\n   *   predicate.\n   */\n  filter: (predicate: (value: K) => boolean) => ISetMapped<K, KM>;\n\n  /**\n   * Filters the elements of the set by excluding elements for which the\n   * predicate returns true.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const withoutEven = set.filterNot((point) => point.x % 2 === 0);\n   *\n   * assert.deepStrictEqual(Array.from(withoutEven), [{ x: 1, tag: 'a' }]);\n   * ```\n   *\n   * @param predicate A function to test each element.\n   * @returns A new ISetMapped instance with elements for which the predicate\n   *   returned `false`.\n   */\n  filterNot: (predicate: (key: K) => boolean) => ISetMapped<K, KM>;\n\n  // Side effects\n\n  /**\n   * Executes a callback function for each element in the set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const mut_collected: Point[] = [];\n   *\n   * set.forEach((point) => {\n   *   mut_collected.push(point);\n   * });\n   *\n   * assert.deepStrictEqual(mut_collected, [\n   *   { x: 1, tag: 'a' },\n   *   { x: 2, tag: 'b' },\n   * ]);\n   * ```\n   *\n   * @param callbackfn A function to execute for each element.\n   */\n  forEach: (callbackfn: (key: K) => void) => void;\n\n  // Comparison\n\n  /**\n   * Checks if this set is a subset of another set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const subset = ISetMapped.create<Point, string>(\n   *   [{ x: 1, tag: 'a' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const superset = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.isTrue(subset.isSubsetOf(superset));\n   *\n   * assert.isFalse(superset.isSubsetOf(subset));\n   * ```\n   *\n   * @param set The other set.\n   * @returns `true` if this set is a subset of the other set, `false`\n   *   otherwise.\n   */\n  isSubsetOf: (set: ISetMapped<K, KM>) => boolean;\n\n  /**\n   * Checks if this set is a superset of another set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const superset = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const subset = ISetMapped.create<Point, string>(\n   *   [{ x: 2, tag: 'b' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.isTrue(superset.isSupersetOf(subset));\n   *\n   * assert.isFalse(subset.isSupersetOf(superset));\n   * ```\n   *\n   * @param set The other set.\n   * @returns `true` if this set is a superset of the other set, `false`\n   *   otherwise.\n   */\n  isSupersetOf: (set: ISetMapped<K, KM>) => boolean;\n\n  /**\n   * Returns a new set with elements that are in this set but not in another\n   * set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const left = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *     { x: 3, tag: 'c' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const right = ISetMapped.create<Point, string>(\n   *   [{ x: 2, tag: 'b' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const difference = left.subtract(right);\n   *\n   * assert.deepStrictEqual(Array.from(difference), [\n   *   { x: 1, tag: 'a' },\n   *   { x: 3, tag: 'c' },\n   * ]);\n   * ```\n   *\n   * @param set The other set.\n   * @returns A new ISetMapped instance representing the set difference.\n   */\n  subtract: (set: ISetMapped<K, KM>) => ISetMapped<K, KM>;\n\n  /**\n   * Returns a new set with elements that are common to both this set and\n   * another set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const left = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const right = ISetMapped.create<Point, string>(\n   *   [{ x: 2, tag: 'b' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const intersection = left.intersect(right);\n   *\n   * assert.deepStrictEqual(Array.from(intersection), [{ x: 2, tag: 'b' }]);\n   * ```\n   *\n   * @param set The other set.\n   * @returns A new ISetMapped instance representing the set intersection.\n   */\n  intersect: (set: ISetMapped<K, KM>) => ISetMapped<K, KM>;\n\n  /**\n   * Returns a new set with all elements from both this set and another set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const left = ISetMapped.create<Point, string>(\n   *   [{ x: 1, tag: 'a' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const right = ISetMapped.create<Point, string>(\n   *   [{ x: 2, tag: 'b' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const combined = left.union(right);\n   *\n   * assert.deepStrictEqual(Array.from(combined), [\n   *   { x: 1, tag: 'a' },\n   *   { x: 2, tag: 'b' },\n   * ]);\n   * ```\n   *\n   * @param set The other set.\n   * @returns A new ISetMapped instance representing the set union.\n   */\n  union: (set: ISetMapped<K, KM>) => ISetMapped<K, KM>;\n\n  // Iterators\n\n  /**\n   * Returns an iterator for the elements in the set (alias for values).\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.deepStrictEqual(Array.from(set.keys()), [\n   *   { x: 1, tag: 'a' },\n   *   { x: 2, tag: 'b' },\n   * ]);\n   * ```\n   *\n   * @returns An iterable iterator of elements.\n   */\n  keys: () => IterableIterator<K>;\n\n  /**\n   * Returns an iterator for the elements in the set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.deepStrictEqual(Array.from(set.values()), [\n   *   { x: 1, tag: 'a' },\n   *   { x: 2, tag: 'b' },\n   * ]);\n   * ```\n   *\n   * @returns An iterable iterator of elements.\n   */\n  values: () => IterableIterator<K>;\n\n  /**\n   * Returns an iterator for the entries (element-element pairs) in the set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.deepStrictEqual(Array.from(set.entries()), [\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 1, tag: 'a' },\n   *   ],\n   *   [\n   *     { x: 2, tag: 'b' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   * ]);\n   * ```\n   *\n   * @returns An iterable iterator of entries.\n   */\n  entries: () => IterableIterator<readonly [K, K]>;\n\n  // Conversion\n\n  /**\n   * Converts the elements of the set to an array.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.deepStrictEqual(set.toArray(), [\n   *   { x: 1, tag: 'a' },\n   *   { x: 2, tag: 'b' },\n   * ]);\n   * ```\n   *\n   * @returns A readonly array of elements.\n   */\n  toArray: () => readonly K[];\n\n  /**\n   * Returns the underlying readonly JavaScript Set of mapped keys.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [{ x: 1, tag: 'a' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const raw = set.toRawSet();\n   *\n   * assert.isTrue(isSet(raw));\n   *\n   * assert.isTrue(raw.has(toKey({ x: 1, tag: 'a' })));\n   * ```\n   *\n   * @returns The raw ReadonlySet instance.\n   */\n  toRawSet: () => ReadonlySet<KM>;\n}>;\n\n/**\n * Represents an immutable set with custom element transformation and\n * high-performance operations.\n *\n * ISetMapped is a specialized persistent data structure that enables using\n * complex objects as set elements while maintaining the performance benefits of\n * JavaScript's native Set. It achieves this by requiring bidirectional\n * transformation functions that convert between your custom element type and a\n * primitive type that can be efficiently stored and compared for uniqueness.\n *\n * **Key Features:**\n *\n * - **Complex Elements**: Use objects, arrays, or any custom type as set elements\n * - **Immutable**: All mutation operations return new instances\n * - **Type Safe**: Full TypeScript support with compile-time element type\n *   checking\n * - **Bidirectional**: Maintains ability to reconstruct original elements from\n *   mapped keys\n * - **Set Algebra**: Complete support for mathematical set operations\n *\n * **Use Cases:**\n *\n * - Sets of entities with complex identifiers\n * - Deduplication of objects based on specific properties\n * - Performance-critical sets with non-primitive elements\n * - Mathematical set operations on complex data structures\n *\n * @template K The type of the custom elements in the set.\n * @template KM The type of the mapped primitive keys (string, number, etc.).\n */\nexport type ISetMapped<K, KM extends MapSetKeyType> = Iterable<K> &\n  Readonly<ISetMappedInterface<K, KM>>;\n\n/** Provides utility functions for ISetMapped. */\nexport namespace ISetMapped {\n  /**\n   * Creates a new ISetMapped instance with custom element transformation\n   * functions.\n   *\n   * This factory function creates an immutable set that can use complex objects\n   * as elements by providing bidirectional transformation functions. The\n   * `toKey` function converts your custom element type to a primitive type that\n   * can be efficiently stored, while `fromKey` reconstructs the original\n   * element type for iteration and access.\n   *\n   * **Performance:** O(n) where n is the number of elements in the iterable.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.deepStrictEqual(Array.from(set), [\n   *   { x: 1, tag: 'a' },\n   *   { x: 2, tag: 'b' },\n   * ]);\n   * ```\n   *\n   * @template K The type of the custom elements.\n   * @template KM The type of the mapped primitive keys.\n   * @param iterable An iterable of elements using the custom element type.\n   * @param toKey A function that converts a custom element `K` to a primitive\n   *   key `KM`. This function must be deterministic and produce unique values\n   *   for unique elements.\n   * @param fromKey A function that converts a primitive key `KM` back to the\n   *   custom element `K`. This should be the inverse of `toKey`.\n   * @returns A new ISetMapped instance containing all unique elements from the\n   *   iterable.\n   */\n  export const create = <K, KM extends MapSetKeyType>(\n    iterable: Iterable<K>,\n    toKey: (a: K) => KM,\n    fromKey: (k: KM) => K,\n  ): ISetMapped<K, KM> => new ISetMappedClass<K, KM>(iterable, toKey, fromKey);\n\n  /**\n   * Checks if two ISetMapped instances are structurally equal.\n   *\n   * Two ISetMapped instances are considered equal if they have the same size\n   * and contain exactly the same elements. The comparison is performed on the\n   * underlying mapped keys, so the transformation functions themselves don't\n   * need to be identical. Elements are compared based on their mapped key\n   * representations.\n   *\n   * **Performance:** O(n) where n is the size of the smaller set.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const first = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const second = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 2, tag: 'b' },\n   *     { x: 1, tag: 'a' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const third = ISetMapped.create<Point, string>(\n   *   [{ x: 3, tag: 'c' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * assert.isTrue(ISetMapped.equal(first, second));\n   *\n   * assert.isFalse(ISetMapped.equal(first, third));\n   * ```\n   *\n   * @template K The type of the custom elements.\n   * @template KM The type of the mapped primitive keys.\n   * @param a The first ISetMapped instance to compare.\n   * @param b The second ISetMapped instance to compare.\n   * @returns `true` if the sets contain exactly the same elements, `false`\n   *   otherwise.\n   */\n  export const equal = <K, KM extends MapSetKeyType>(\n    a: ISetMapped<K, KM>,\n    b: ISetMapped<K, KM>,\n  ): boolean => a.size === b.size && a.every((e) => b.has(e));\n\n  /**\n   * Computes the difference between two ISetMapped instances.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const previous = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const current = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 2, tag: 'b' },\n   *     { x: 3, tag: 'c' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const { added, deleted } = ISetMapped.diff(previous, current);\n   *\n   * assert.deepStrictEqual(Array.from(added), [{ x: 3, tag: 'c' }]);\n   *\n   * assert.deepStrictEqual(Array.from(deleted), [{ x: 1, tag: 'a' }]);\n   * ```\n   *\n   * @template K The type of the elements.\n   * @template KM The type of the mapped keys.\n   * @param oldSet The original set.\n   * @param newSet The new set.\n   * @returns An object containing sets of added and deleted elements.\n   */\n  export const diff = <K, KM extends MapSetKeyType>(\n    oldSet: ISetMapped<K, KM>,\n    newSet: ISetMapped<K, KM>,\n  ): ReadonlyRecord<'added' | 'deleted', ISetMapped<K, KM>> =>\n    ({\n      deleted: oldSet.subtract(newSet),\n      added: newSet.subtract(oldSet),\n    }) as const;\n\n  /**\n   * Computes the intersection of two ISetMapped instances.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const left = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const right = ISetMapped.create<Point, string>(\n   *   [{ x: 2, tag: 'b' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const overlap = ISetMapped.intersection(left, right);\n   *\n   * assert.deepStrictEqual(Array.from(overlap), [{ x: 2, tag: 'b' }]);\n   * ```\n   *\n   * @template K The type of the elements.\n   * @template KM The type of the mapped keys.\n   * @param a The first set.\n   * @param b The second set.\n   * @returns A new ISetMapped instance representing the intersection.\n   */\n  export const intersection = <K, KM extends MapSetKeyType>(\n    a: ISetMapped<K, KM>,\n    b: ISetMapped<K, KM>,\n  ): ISetMapped<K, KM> => a.intersect(b);\n\n  /**\n   * Computes the union of two ISetMapped instances.\n   *\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const left = ISetMapped.create<Point, string>(\n   *   [{ x: 1, tag: 'a' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const right = ISetMapped.create<Point, string>(\n   *   [{ x: 2, tag: 'b' }],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const combined = ISetMapped.union(left, right);\n   *\n   * assert.deepStrictEqual(Array.from(combined), [\n   *   { x: 1, tag: 'a' },\n   *   { x: 2, tag: 'b' },\n   * ]);\n   * ```\n   *\n   * @template K The type of the elements.\n   * @template KM The type of the mapped keys.\n   * @param a The first set.\n   * @param b The second set.\n   * @returns A new ISetMapped instance representing the union.\n   */\n  export const union = <K, KM extends MapSetKeyType>(\n    a: ISetMapped<K, KM>,\n    b: ISetMapped<K, KM>,\n  ): ISetMapped<K, KM> => a.union(b);\n}\n\n/**\n * Internal class implementation for ISetMapped providing immutable set\n * operations with element transformation.\n *\n * This class implements the ISetMapped interface by maintaining a JavaScript\n * Set with primitive keys internally while exposing an API that works with\n * custom element types. The transformation between custom and primitive\n * elements is handled transparently through the provided `toKey` and `fromKey`\n * functions.\n *\n * **Implementation Details:**\n *\n * - Uses ReadonlySet<KM> internally where KM is the primitive key type\n * - Stores transformation functions for bidirectional element conversion\n * - Implements copy-on-write semantics for efficiency\n * - Provides optional debug messaging for development\n *\n * @template K The type of the custom elements.\n * @template KM The type of the mapped primitive keys.\n * @implements ISetMapped\n * @implements Iterable\n * @internal This class should not be used directly. Use ISetMapped.create() instead.\n */\nclass ISetMappedClass<K, KM extends MapSetKeyType>\n  implements ISetMapped<K, KM>, Iterable<K>\n{\n  readonly #set: ReadonlySet<KM>;\n  readonly #toKey: (a: K) => KM;\n  readonly #fromKey: (k: KM) => K;\n  readonly #showNotFoundMessage: boolean;\n\n  /**\n   * Constructs an ISetMappedClass instance with custom element transformation.\n   *\n   * @param iterable An iterable of elements using the custom element type K.\n   * @param toKey A function that converts a custom element K to a primitive key\n   *   KM. Must be deterministic and produce unique values for unique elements.\n   * @param fromKey A function that converts a primitive key KM back to the\n   *   custom element K. Should be the inverse of the toKey function.\n   * @param showNotFoundMessage Whether to log warning messages when operations\n   *   are performed on non-existent elements. Useful for debugging. Defaults to\n   *   false for production use.\n   * @internal Use ISetMapped.create() instead of calling this constructor directly.\n   */\n  constructor(\n    iterable: Iterable<K>,\n    toKey: (a: K) => KM,\n    fromKey: (k: KM) => K,\n    showNotFoundMessage: boolean = false,\n  ) {\n    this.#set = new Set(Array.from(iterable, toKey));\n\n    this.#toKey = toKey;\n\n    this.#fromKey = fromKey;\n\n    this.#showNotFoundMessage = showNotFoundMessage;\n  }\n\n  /** @inheritdoc */\n  get size(): SizeType.Arr {\n    return asUint32(this.#set.size);\n  }\n\n  /** @inheritdoc */\n  get isEmpty(): boolean {\n    return this.size === 0;\n  }\n\n  /** @inheritdoc */\n  has(key: K | (WidenLiteral<K> & {})): boolean {\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return this.#set.has(this.#toKey(key as K));\n  }\n\n  /** @inheritdoc */\n  every<L extends K>(\n    predicate: (key: K) => key is L,\n  ): this is ISetMapped<L, KM>;\n\n  /** @inheritdoc */\n  every(predicate: (key: K) => boolean): boolean;\n\n  /** @inheritdoc */\n  every(predicate: (key: K) => boolean): boolean {\n    for (const key of this.values()) {\n      if (!predicate(key)) return false;\n    }\n\n    return true;\n  }\n\n  /** @inheritdoc */\n  some(predicate: (key: K) => boolean): boolean {\n    for (const key of this.values()) {\n      if (predicate(key)) return true;\n    }\n\n    return false;\n  }\n\n  /** @inheritdoc */\n  add(key: K): ISetMapped<K, KM> {\n    if (this.has(key)) return this;\n\n    return ISetMapped.create(\n      [...this.#set, this.#toKey(key)].map(this.#fromKey),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  delete(key: K): ISetMapped<K, KM> {\n    if (!this.has(key)) {\n      if (this.#showNotFoundMessage) {\n        console.warn(\n          `ISetMapped.delete: key not found: ${String(this.#toKey(key))}`,\n        );\n      }\n\n      return this;\n    }\n\n    const keyMapped = this.#toKey(key);\n\n    return ISetMapped.create(\n      Array.from(this.#set)\n        .filter((k) => !Object.is(k, keyMapped))\n        .map(this.#fromKey),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  withMutations(\n    actions: readonly Readonly<\n      { type: 'add'; key: K } | { type: 'delete'; key: K }\n    >[],\n  ): ISetMapped<K, KM> {\n    const mut_result = new Set<KM>(this.#set);\n\n    const updateFn = (\n      action: Readonly<{ type: 'add'; key: K } | { type: 'delete'; key: K }>,\n    ): void => {\n      const key = this.#toKey(action.key);\n\n      switch (action.type) {\n        case 'delete':\n          mut_result.delete(key);\n\n          break;\n\n        case 'add':\n          mut_result.add(key);\n\n          break;\n      }\n    };\n\n    for (const action of actions) {\n      updateFn(action);\n    }\n\n    return ISetMapped.create<K, KM>(\n      Array.from(mut_result, this.#fromKey),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  map(mapFn: (key: K) => K): ISetMapped<K, KM> {\n    return ISetMapped.create(\n      this.toArray().map(mapFn),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  filter(predicate: (key: K) => boolean): ISetMapped<K, KM> {\n    return ISetMapped.create(\n      this.toArray().filter(predicate),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  filterNot(predicate: (key: K) => boolean): ISetMapped<K, KM> {\n    return ISetMapped.create(\n      this.toArray().filter((k) => !predicate(k)),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  forEach(callbackfn: (key: K) => void): void {\n    for (const km of this.#set) {\n      callbackfn(this.#fromKey(km));\n    }\n  }\n\n  /** @inheritdoc */\n  isSubsetOf(set: ISetMapped<K, KM>): boolean {\n    return this.every((k) => set.has(k));\n  }\n\n  /** @inheritdoc */\n  isSupersetOf(set: ISetMapped<K, KM>): boolean {\n    return set.every((k) => this.has(k));\n  }\n\n  /** @inheritdoc */\n  subtract(set: ISetMapped<K, KM>): ISetMapped<K, KM> {\n    return ISetMapped.create(\n      this.toArray().filter((k) => !set.has(k)),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  intersect(set: ISetMapped<K, KM>): ISetMapped<K, KM> {\n    return ISetMapped.create(\n      this.toArray().filter((k) => set.has(k)),\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /** @inheritdoc */\n  union(set: ISetMapped<K, KM>): ISetMapped<K, KM> {\n    return ISetMapped.create(\n      [...this.values(), ...set.values()],\n      this.#toKey,\n      this.#fromKey,\n    );\n  }\n\n  /**\n   * @example\n   *\n   * ```ts\n   * type Point = Readonly<{ x: number; tag: string }>;\n   *\n   * const toKey = (point: Point) => JSON.stringify(point);\n   *\n   * // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n   * const fromKey = (key: string) => JSON.parse(key) as Point;\n   *\n   * const set = ISetMapped.create<Point, string>(\n   *   [\n   *     { x: 1, tag: 'a' },\n   *     { x: 2, tag: 'b' },\n   *   ],\n   *   toKey,\n   *   fromKey,\n   * );\n   *\n   * const collected = Array.from(set);\n   *\n   * assert.deepStrictEqual(collected, [\n   *   { x: 1, tag: 'a' },\n   *   { x: 2, tag: 'b' },\n   * ]);\n   * ```\n   *\n   * @inheritdoc\n   */\n  *[Symbol.iterator](): Iterator<K> {\n    for (const k of this.keys()) {\n      yield k;\n    }\n  }\n\n  /** @inheritdoc */\n  *keys(): IterableIterator<K> {\n    for (const km of this.#set) {\n      yield this.#fromKey(km);\n    }\n  }\n\n  /** @inheritdoc */\n  *values(): IterableIterator<K> {\n    for (const km of this.#set) {\n      // JavaScript Set's values() is an alias for keys()\n      yield this.#fromKey(km);\n    }\n  }\n\n  /** @inheritdoc */\n  *entries(): IterableIterator<readonly [K, K]> {\n    for (const km of this.#set) {\n      // JavaScript Set's entries() yields [value, value]\n      const a = this.#fromKey(km);\n\n      yield [a, a];\n    }\n  }\n\n  /** @inheritdoc */\n  toArray(): readonly K[] {\n    return Array.from(this.values());\n  }\n\n  /** @inheritdoc */\n  toRawSet(): ReadonlySet<KM> {\n    return this.#set;\n  }\n}\n"],"names":["ISetMapped"],"mappings":"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"}

package/dist/collections/iset.d.mts

@@ -574,7 +574,7 @@ export declare namespace ISet {
      * @returns An object with `added` and `deleted` properties, each containing
      *   an ISet of elements that were added or removed respectively.
      */
-    const diff: <K extends MapSetKeyType>(oldSet: ISet<K>, newSet: ISet<K>) => ReadonlyRecord<"added" | "deleted", ISet<K>>;
+    const diff: <K extends MapSetKeyType>(oldSet: ISet<K>, newSet: ISet<K>) => ReadonlyRecord<'added' | 'deleted', ISet<K>>;
     /**
      * Computes the intersection of two ISet instances.
      *

package/dist/collections/iset.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"iset.d.mts","sourceRoot":"","sources":["../../src/collections/iset.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"iset.d.mts","sourceRoot":"","sources":["../../src/collections/iset.mts"],"names":[],"mappings":"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"}