npm - ts-data-forge - Versions diffs - 14.6.1 → 14.6.3 - Mend

ts-data-forge 14.6.1 → 14.6.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (420) hide show

package/dist/collections/iset.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"iset.mjs","sources":["../../src/collections/iset.mts"],"sourcesContent":["/* eslint-disable unicorn/prefer-iterator-to-array-at-end /\nimport {\n type FixedLengthTuple,\n type ReadonlyRecord,\n type WidenLiteral,\n} from 'ts-type-forge';\nimport { asUint32 } from '../number/index.mjs';\nimport { unknownToString } from '../others/index.mjs';\nimport { type MapSetKeyType, type SizeType } from '../types.mjs';\n\n/\n Interface for an immutable set with membership testing and set operation\n * support.\n \n This interface defines all methods and properties available on ISet\n * instances. All operations that modify the set return new ISet instances,\n * preserving immutability. The underlying implementation uses JavaScript's\n * native Set but creates copies on mutations to maintain immutability.\n \n Immutability Guarantees:\n \n - All mutation operations (add, delete) return new ISet instances\n * - Original ISet instances are never modified\n * - Safe for concurrent access and functional programming patterns\n \n Performance Characteristics:\n \n - has: O(1) average case\n * - add/delete: O(n) due to copying for immutability\n * - set operations (union, intersection, difference): O(n)\n * - map/filter operations: O(n)\n * - iteration: O(n)\n \n @template K The type of the elements in the set. Must extend MapSetKeyType\n * (string, number, boolean, etc.)\n /\ntype ISetInterface<K extends MapSetKeyType> = Readonly<{\n // Getting information\n\n /\n The number of elements in the set.\n \n @example\n \n ```ts\n * const set = ISet.create([1, 2, 3]);\n \n assert.isTrue(set.size === 3);\n * ```\n /\n size: SizeType.Arr;\n\n /\n Checks if the set is empty.\n \n @example\n \n ```ts\n * const emptySet = ISet.create<number>([]);\n \n const filledSet = ISet.create([1, 2]);\n \n assert.isTrue(emptySet.isEmpty);\n \n assert.isFalse(filledSet.isEmpty);\n * ```\n /\n isEmpty: boolean;\n\n /\n Checks if an element exists in the set. Allows for wider literal types for\n * keys during checking.\n \n @example\n \n ```ts\n * const set = ISet.create(['apple', 'banana']);\n \n assert.isTrue(set.has('apple'));\n \n assert.isFalse(set.has('cherry'));\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 predicate. Also supports a\n * type predicate overload that narrows the type of elements in the set if\n * the predicate returns true for all elements.\n \n @example\n \n ```ts\n * const numbers = ISet.create([2, 4, 6]);\n \n const allEven = numbers.every((value) => value % 2 === 0);\n \n const narrowed = numbers.every(\n * (value): value is 2 \| 4 \| 6 => value % 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>(predicate: (key: K) => key is L) => this is ISet<L>);\n\n /\n Checks if at least one element in the set satisfies a predicate.\n \n @example\n \n ```ts\n * const numbers = ISet.create([1, 3, 5]);\n \n assert.isTrue(numbers.some((value) => value > 4));\n \n assert.isFalse(numbers.some((value) => value > 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 * const base = ISet.create<number>([1, 2]);\n \n const withThree = base.add(3);\n \n const unchanged = base.add(2);\n \n assert.deepStrictEqual(Array.from(withThree), [1, 2, 3]);\n \n assert.isTrue(unchanged === base);\n * ```\n \n @param key The element to add.\n * @returns A new ISet instance with the element added.\n /\n add: (key: K) => ISet<K>;\n\n /\n Deletes an element from the set.\n \n @example\n \n ```ts\n * const base = ISet.create<number>([1, 2, 3]);\n \n const withoutTwo = base.delete(2);\n \n const unchanged = base.delete(4);\n \n assert.deepStrictEqual(Array.from(withoutTwo), [1, 3]);\n \n assert.isTrue(unchanged === base);\n * ```\n \n @param key The element to delete.\n * @returns A new ISet instance without the specified element.\n /\n delete: (key: K) => ISet<K>;\n\n /\n Applies a series of mutations to the set.\n \n @example\n \n ```ts\n * const base = ISet.create<string>(['a', 'b']);\n \n const actions: readonly Readonly<\n * { type: 'add'; key: string } \| { type: 'delete'; key: string }\n * >[] = [\n * { type: 'add', key: 'c' },\n * { type: 'delete', key: 'a' },\n * ] as const;\n \n const mutated = base.withMutations(actions);\n \n assert.deepStrictEqual(Array.from(mutated), ['b', 'c']);\n \n assert.deepStrictEqual(Array.from(base), ['a', 'b']);\n * ```\n \n @param actions An array of mutation actions (add or delete).\n * @returns A new ISet instance with all mutations applied.\n /\n withMutations: (\n actions: readonly Readonly<\n { type: 'add'; key: K } \| { type: 'delete'; key: K }\n >[],\n ) => ISet<K>;\n\n // Sequence algorithms\n\n /\n Maps the elements of the set to new elements.\n \n @example\n \n ```ts\n * const letters = ISet.create(['a', 'b']);\n \n const upper = letters.map((value) => value.toUpperCase());\n \n assert.deepStrictEqual(Array.from(upper), ['A', 'B']);\n * ```\n \n @template K2 The type of the new elements.\n * @param mapFn A function that maps an element to a new element.\n * @returns A new ISet instance with mapped elements.\n /\n map: <K2 extends MapSetKeyType>(mapFn: (key: K) => K2) => ISet<K2>;\n\n /\n Filters the elements of the set based on a predicate. Also supports a type\n * predicate overload that narrows the type of elements in the resulting set.\n \n @example\n \n ```ts\n * const letters = ISet.create(['apple', 'bee', 'cat']);\n \n const shortWords = letters.filter((value) => value.length <= 3);\n \n const narrowed = letters.filter(\n * (value): value is 'bee' \| 'cat' => value.length === 3,\n * );\n \n assert.deepStrictEqual(Array.from(shortWords), ['bee', 'cat']);\n \n assert.deepStrictEqual(Array.from(narrowed), ['bee', 'cat']);\n * ```\n \n @template K2 The narrowed type of the elements.\n * @param predicate A function to test each element.\n * @returns A new ISet instance with elements that satisfy the predicate.\n /\n filter: (<K2 extends K>(predicate: (key: K) => key is K2) => ISet<K2>) &\n ((predicate: (key: K) => boolean) => ISet<K>);\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 * const numbers = ISet.create([1, 2, 3, 4]);\n \n const withoutEven = numbers.filterNot((value) => value % 2 === 0);\n \n assert.deepStrictEqual(Array.from(withoutEven), [1, 3]);\n * ```\n \n @param predicate A function to test each element.\n * @returns A new ISet instance with elements for which the predicate returned\n * `false`.\n /\n filterNot: (predicate: (key: K) => boolean) => ISet<K>;\n\n // Set operations\n\n /\n Checks if this set is a subset of another set.\n \n @example\n \n ```ts\n * const subset = ISet.create<number>([1, 2]);\n \n const superset = ISet.create<number>([1, 2, 3]);\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: ISet<WidenLiteral<K>>) => boolean;\n\n /\n Checks if this set is a superset of another set.\n \n @example\n \n ```ts\n * const superset = ISet.create<string>(['a', 'b', 'c']);\n \n const subset = ISet.create<string>(['a', 'c']);\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: ISet<WidenLiteral<K>>) => 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 * const all = ISet.create<number>([1, 2, 3, 4]);\n \n const toRemove = ISet.create<number>([2, 4]);\n \n const difference = all.subtract(toRemove);\n \n assert.deepStrictEqual(Array.from(difference), [1, 3]);\n * ```\n \n @param set The other set.\n * @returns A new ISet instance representing the set difference.\n /\n subtract: (set: ISet<K>) => ISet<K>;\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 * const left = ISet.create<string>(['x', 'y']);\n \n const right = ISet.create<string>(['y', 'z']);\n \n const shared = left.intersect(right);\n \n assert.deepStrictEqual(Array.from(shared), ['y']);\n * ```\n \n @param set The other set.\n * @returns A new ISet instance representing the set intersection.\n /\n intersect: (set: ISet<K>) => ISet<K>;\n\n /\n Returns a new set with all elements from both this set and another set.\n \n @example\n \n ```ts\n * const numbers = ISet.create([1, 2]);\n \n const letters = ISet.create(['a', 'b']);\n \n const combined = numbers.union(letters);\n \n assert.deepStrictEqual(Array.from(combined), [1, 2, 'a', 'b']);\n * ```\n \n @template K2 The type of elements in the other set.\n * @param set The other set.\n * @returns A new ISet instance representing the set union.\n /\n union: <K2 extends MapSetKeyType>(set: ISet<K2>) => ISet<K \| K2>;\n\n // Side effects\n\n /\n Executes a callback function for each element in the set.\n \n @example\n \n ```ts\n * const set = ISet.create(['alpha', 'beta']);\n \n const mut_collected: string[] = [];\n \n set.forEach((value) => {\n * mut_collected.push(value);\n * });\n \n assert.deepStrictEqual(mut_collected, ['alpha', 'beta']);\n * ```\n \n @param callbackfn A function to execute for each element.\n /\n forEach: (callbackfn: (key: K) => void) => void;\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 * const set = ISet.create([1, 2]);\n \n const keys = Array.from(set.keys());\n \n assert.deepStrictEqual(keys, [1, 2]);\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 * const set = ISet.create(['x', 'y']);\n \n const values = Array.from(set.values());\n \n assert.deepStrictEqual(values, ['x', 'y']);\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 * const set = ISet.create(['red', 'blue']);\n \n const entries = Array.from(set.entries());\n \n assert.deepStrictEqual(entries, [\n * ['red', 'red'],\n * ['blue', 'blue'],\n * ]);\n * ```\n \n @returns An iterable iterator of entries.\n /\n entries: () => IterableIterator<FixedLengthTuple<2, K>>;\n\n // Conversion\n\n /\n Converts the elements of the set to an array.\n \n @example\n \n ```ts\n * const set = ISet.create(['north', 'south']);\n \n assert.deepStrictEqual(set.toArray(), ['north', 'south']);\n * ```\n \n @returns A readonly array of elements.\n /\n toArray: () => readonly K[];\n\n /\n Returns the underlying readonly JavaScript Set.\n \n @example\n \n ```ts\n * const set = ISet.create(['alpha']);\n \n const raw = set.toRawSet();\n \n assert.isTrue(isSet(raw));\n \n assert.isTrue(raw.has('alpha'));\n * ```\n \n @returns The raw ReadonlySet instance.\n /\n toRawSet: () => ReadonlySet<K>;\n}>;\n\n/\n Represents an immutable set with high-performance operations and\n * comprehensive set algebra support.\n \n ISet is a persistent data structure that provides all the functionality of\n * JavaScript's Set while maintaining immutability. All operations that would\n * normally mutate the set instead return new ISet instances, making it safe for\n * functional programming and concurrent access.\n \n Key Features:\n \n - Immutable: All mutation operations return new instances\n * - Set Operations: Full support for union, intersection, difference,\n * subset/superset checks\n * - Type Safe: Full TypeScript support with generic element types\n * - Iterable: Implements standard JavaScript iteration protocols\n * - Functional: Rich API for map, filter, and functional composition\n \n When to Use:\n \n - Managing collections of unique values with immutability guarantees\n * - Set algebra operations (unions, intersections, differences)\n * - Membership testing with O(1) performance\n * - Functional programming patterns requiring immutable collections\n \n @template K The type of the elements in the set. Must extend MapSetKeyType.\n /\nexport type ISet<K extends MapSetKeyType> = Iterable<K> & ISetInterface<K>;\n\n/* Provides utility functions for ISet. /\nexport namespace ISet {\n /\n Creates a new ISet instance from an iterable of elements.\n \n This factory function accepts any iterable of elements, including arrays,\n * JavaScript Sets, other ISets, or custom iterables. Duplicate elements in\n * the input iterable will be automatically deduplicated in the resulting\n * set.\n \n Performance: O(n) where n is the number of elements in the iterable.\n \n @example\n \n ```ts\n * const set = ISet.create(['a', 'a', 'b']);\n \n assert.deepStrictEqual(Array.from(set), ['a', 'b']);\n * ```\n \n @template K The type of the elements. Must extend MapSetKeyType.\n * @param iterable An iterable of elements (e.g., Array, Set, ISet, etc.)\n * @returns A new ISet instance containing all unique elements from the\n * iterable.\n /\n export const create = <K extends MapSetKeyType>(\n iterable: Iterable<K>,\n ): ISet<K> => new ISetClass<K>(iterable);\n\n /\n Checks if two ISet instances are structurally equal.\n \n Two ISets are considered equal if they have the same size and contain\n * exactly the same elements. The order of elements does not matter for\n * equality comparison since sets are unordered collections. Elements are\n * compared using JavaScript's `===` operator.\n \n Performance: O(n) where n is the size of the smaller set.\n \n @example\n \n ```ts\n * const first = ISet.create<number>([1, 2]);\n \n const second = ISet.create<number>([2, 1]);\n \n const third = ISet.create<number>([1, 3]);\n \n assert.isTrue(ISet.equal(first, second));\n \n assert.isFalse(ISet.equal(first, third));\n * ```\n \n @template K The type of the elements.\n * @param a The first ISet instance to compare.\n * @param b The second ISet instance to compare.\n * @returns `true` if the sets contain exactly the same elements, `false`\n * otherwise.\n /\n export const equal = <K extends MapSetKeyType>(\n a: ISet<K>,\n b: ISet<K>,\n ): boolean => a.size === b.size && a.every((e) => b.has(e));\n\n /\n Computes the difference between two ISet instances, identifying added and\n * deleted elements.\n \n This function performs a set difference operation to determine what\n * elements were added and what elements were deleted when transitioning from\n * the old set to the new set. This is useful for change detection, state\n * management, and synchronization scenarios.\n \n Performance: O(n + m) where n and m are the sizes of the old and new\n * sets respectively.\n \n @example\n \n ```ts\n * const previous = ISet.create<string>(['draft', 'review']);\n \n const current = ISet.create<string>(['review', 'published']);\n \n const { added, deleted } = ISet.diff(previous, current);\n \n assert.deepStrictEqual(Array.from(added), ['published']);\n \n assert.deepStrictEqual(Array.from(deleted), ['draft']);\n * ```\n \n @template K The type of the elements.\n * @param oldSet The original set representing the previous state.\n * @param newSet The new set representing the current state.\n * @returns An object with `added` and `deleted` properties, each containing\n * an ISet of elements that were added or removed respectively.\n /\n export const diff = <K extends MapSetKeyType>(\n oldSet: ISet<K>,\n newSet: ISet<K>,\n ): ReadonlyRecord<'added' \| 'deleted', ISet<K>> =>\n ({\n deleted: oldSet.subtract(newSet),\n added: newSet.subtract(oldSet),\n }) as const;\n\n /\n Computes the intersection of two ISet instances.\n \n Returns a new set containing only the elements that are present in both\n * input sets. This operation is commutative: `intersection(a, b) ===\n * intersection(b, a)`.\n \n Performance: O(min(n, m)) where n and m are the sizes of the input\n * sets.\n \n @example\n \n ```ts\n * const left = ISet.create<number>([1, 2, 3]);\n \n const right = ISet.create<number>([2, 4]);\n \n const overlap = ISet.intersection(left, right);\n \n assert.deepStrictEqual(Array.from(overlap), [2]);\n * ```\n \n @template K The type of the elements.\n * @param a The first set.\n * @param b The second set.\n * @returns A new ISet instance containing elements common to both sets.\n /\n export const intersection = <K extends MapSetKeyType>(\n a: ISet<K>,\n b: ISet<K>,\n ): ISet<K> => a.intersect(b);\n\n /\n Computes the union of two ISet instances.\n \n Returns a new set containing all elements that are present in either input\n * set. Duplicate elements are automatically handled since sets only contain\n * unique values. This operation is commutative: `union(a, b) === union(b,\n * a)`.\n \n Performance: O(n + m) where n and m are the sizes of the input sets.\n \n @example\n \n ```ts\n * const numbers = ISet.create([1, 2]);\n \n const words = ISet.create(['one', 'two']);\n \n const union = ISet.union(numbers, words);\n \n assert.deepStrictEqual(Array.from(union), [1, 2, 'one', 'two']);\n * ```\n \n @template K1 The type of elements in the first set.\n * @template K2 The type of elements in the second set.\n * @param a The first set.\n * @param b The second set.\n * @returns A new ISet instance containing all elements from both sets.\n /\n export const union = <K1 extends MapSetKeyType, K2 extends MapSetKeyType>(\n a: ISet<K1>,\n b: ISet<K2>,\n ): ISet<K1 \| K2> => a.union(b);\n}\n\n/\n Internal class implementation for ISet providing immutable set operations.\n \n This class implements the ISet interface using JavaScript's native Set as the\n * underlying storage mechanism for optimal performance. All mutation operations\n * create new instances rather than modifying the existing set, ensuring\n * immutability.\n \n Implementation Details:\n \n - Uses ReadonlySet<K> internally for type safety and performance\n * - Implements copy-on-write semantics for efficiency\n * - Provides optional debug messaging for development\n \n @template K The type of the elements. Must extend MapSetKeyType.\n * @implements ISet\n * @implements Iterable\n * @internal This class should not be used directly. Use ISet.create() instead.\n /\nclass ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {\n readonly #set: ReadonlySet<K>;\n readonly #showNotFoundMessage: boolean;\n\n /\n Constructs an ISetClass instance with the given elements.\n \n @param iterable An iterable of elements to populate the set.\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 ISet.create() instead of calling this constructor directly.\n /\n constructor(iterable: Iterable<K>, showNotFoundMessage: boolean = false) {\n this.#set = new Set(iterable);\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, @typescript-eslint/no-unnecessary-type-assertion -- unnecessary only under the strict standard library; the stock one types `has` as taking exactly `K`\n return this.#set.has(key as K);\n }\n\n /* @inheritdoc /\n every<L extends K>(predicate: (key: K) => key is L): this is ISet<L>;\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): ISet<K> {\n if (this.has(key)) return this;\n\n return ISet.create([...this.#set, key]);\n }\n\n /* @inheritdoc /\n delete(key: K): ISet<K> {\n if (!this.has(key)) {\n if (this.#showNotFoundMessage) {\n const keyStr = unknownToString(key);\n\n console.warn(`ISet.delete: key not found: ${keyStr}`);\n }\n\n return this;\n }\n\n return ISet.create(Array.from(this.#set).filter((k) => !Object.is(k, key)));\n }\n\n /* @inheritdoc /\n withMutations(\n actions: readonly Readonly<\n { type: 'add'; key: K } \| { type: 'delete'; key: K }\n >[],\n ): ISet<K> {\n const mut_result = new Set<K>(this.#set);\n\n const updateFn = (\n action: Readonly<{ type: 'add'; key: K } \| { type: 'delete'; key: K }>,\n ): void => {\n switch (action.type) {\n case 'delete':\n mut_result.delete(action.key);\n\n break;\n\n case 'add':\n mut_result.add(action.key);\n\n break;\n }\n };\n\n for (const action of actions) {\n updateFn(action);\n }\n\n return ISet.create(mut_result);\n }\n\n /* @inheritdoc /\n map<K2 extends MapSetKeyType>(mapFn: (key: K) => K2): ISet<K2> {\n return ISet.create(this.toArray().map(mapFn));\n }\n\n /* @inheritdoc /\n filter<K2 extends K>(predicate: (key: K) => key is K2): ISet<K2>;\n\n /* @inheritdoc /\n filter(predicate: (key: K) => boolean): ISet<K>;\n\n /* @inheritdoc /\n filter(predicate: (key: K) => boolean): ISet<K> {\n return ISet.create(this.toArray().filter(predicate));\n }\n\n /* @inheritdoc /\n filterNot(predicate: (key: K) => boolean): ISet<K> {\n return ISet.create(this.toArray().filter((e) => !predicate(e)));\n }\n\n /* @inheritdoc /\n forEach(callbackfn: (key: K) => void): void {\n for (const v of this.#set) {\n callbackfn(v);\n }\n }\n\n /* @inheritdoc /\n isSubsetOf(set: ISet<WidenLiteral<K>>): boolean {\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n return this.every((k) => set.has(k as WidenLiteral<K>));\n }\n\n /* @inheritdoc /\n isSupersetOf(set: ISet<WidenLiteral<K>>): boolean {\n // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n return set.every((k) => this.has(k as K));\n }\n\n /* @inheritdoc /\n subtract(set: ISet<K>): ISet<K> {\n return ISet.create(this.toArray().filter((k) => !set.has(k)));\n }\n\n /* @inheritdoc /\n intersect(set: ISet<K>): ISet<K> {\n return ISet.create(this.toArray().filter((k) => set.has(k)));\n }\n\n /* @inheritdoc /\n union<K2 extends MapSetKeyType>(set: ISet<K2>): ISet<K \| K2> {\n return ISet.create([...this, ...set]);\n }\n\n /\n @example\n \n ```ts\n * const set = ISet.create(['first', 'second']);\n \n const collected = Array.from(set);\n \n assert.deepStrictEqual(collected, ['first', 'second']);\n * ```\n \n @inheritdoc\n /\n [Symbol.iterator](): Iterator<K> {\n return this.#set[Symbol.iterator]();\n }\n\n /* @inheritdoc /\n keys(): IterableIterator<K> {\n return this.#set.keys();\n }\n\n /* @inheritdoc /\n values(): IterableIterator<K> {\n return this.#set.values();\n }\n\n /* @inheritdoc /\n entries(): IterableIterator<FixedLengthTuple<2, K>> {\n return this.#set.entries();\n }\n\n /* @inheritdoc /\n toArray(): readonly K[] {\n return Array.from(this.values());\n }\n\n /* @inheritdoc */\n toRawSet(): ReadonlySet<K> {\n return this.#set;\n }\n}\n"],"names":["ISet"],"mappings":"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"}
1	+ {"version":3,"file":"iset.mjs","sourceRoot":"","sources":["../../src/collections/iset.mts"],"names":[],"mappings":"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"}

package/dist/collections/queue.mjs CHANGED Viewed

@@ -1,157 +1,189 @@
-import { none } from '../functional/optional/impl/optional-none.mjs';
-import { some } from '../functional/optional/impl/optional-some.mjs';
-import '@sindresorhus/is';
-import { range } from '../iterator/range.mjs';
-import '../number/branded-types/finite-number.mjs';
-import '../number/branded-types/int.mjs';
-import '../number/branded-types/int16.mjs';
-import '../number/branded-types/int32.mjs';
-import '../number/branded-types/negative-finite-number.mjs';
-import '../number/branded-types/negative-int.mjs';
-import '../number/branded-types/negative-safe-int.mjs';
-import '../number/branded-types/non-negative-finite-number.mjs';
-import '../number/branded-types/non-negative-int16.mjs';
-import '../number/branded-types/non-negative-int32.mjs';
-import '../number/branded-types/non-positive-finite-number.mjs';
-import '../number/branded-types/non-positive-int.mjs';
-import '../number/branded-types/non-positive-safe-int.mjs';
-import '../number/branded-types/non-zero-finite-number.mjs';
-import '../number/branded-types/non-zero-int.mjs';
-import '../number/branded-types/non-zero-int16.mjs';
-import '../number/branded-types/non-zero-int32.mjs';
-import '../number/branded-types/non-zero-safe-int.mjs';
-import '../number/branded-types/non-zero-uint16.mjs';
-import '../number/branded-types/non-zero-uint32.mjs';
-import '../number/branded-types/positive-finite-number.mjs';
-import '../number/branded-types/positive-int.mjs';
-import '../number/branded-types/positive-int16.mjs';
-import '../number/branded-types/positive-int32.mjs';
-import '../number/branded-types/positive-safe-int.mjs';
-import '../number/branded-types/positive-uint16.mjs';
-import '../number/branded-types/positive-uint32.mjs';
-import '../number/branded-types/safe-int.mjs';
-import { asSafeUint } from '../number/branded-types/safe-uint.mjs';
-import '../number/branded-types/uint.mjs';
-import '../number/branded-types/uint16.mjs';
-import { asUint32 } from '../number/branded-types/uint32.mjs';
-import '../number/enum/int8.mjs';
-import '../number/enum/uint8.mjs';
-import '../number/num.mjs';
-import '../number/refined-number-utils.mjs';
+import { Optional } from '../functional/index.mjs';
+import { range } from '../iterator/index.mjs';
+import { asSafeUint, asUint32 } from '../number/index.mjs';
 class QueueClass {
-  /** @internal Initial capacity for new queues. */
-  static #INITIAL_CAPACITY = 8;
-  /** @internal Circular buffer to store queue elements. */
-  #mut_buffer;
-  /** @internal Index of the first element (front of queue). */
-  #mut_head;
-  /** @internal Index where the next element will be added (back of queue). */
-  #mut_tail;
-  /** @internal Current number of elements in the queue. */
-  #mut_size;
-  /** @internal Current capacity of the buffer. */
-  #mut_capacity;
-  /**
-   * Constructs a new QueueClass instance.
-   *
-   * @param initialValues Optional initial values to populate the queue.
-   */
-  constructor(initialValues = []) {
-    const initialCapacity = asUint32(
-      Math.max(QueueClass.#INITIAL_CAPACITY, initialValues.length * 2)
-    );
-    this.#mut_buffer = Array.from(
-      { length: initialCapacity },
-      () => void 0
-    );
-    this.#mut_head = 0;
-    this.#mut_tail = 0;
-    this.#mut_size = 0;
-    this.#mut_capacity = initialCapacity;
-    for (const value of initialValues) {
-      this.enqueue(value);
+    static #INITIAL_CAPACITY = 8;
+    #mut_buffer;
+    #mut_head;
+    #mut_tail;
+    #mut_size;
+    #mut_capacity;
+    constructor(initialValues = []) {
+        const initialCapacity = asUint32(Math.max(QueueClass.#INITIAL_CAPACITY, initialValues.length * 2));
+        this.#mut_buffer = Array.from({ length: initialCapacity }, () => undefined);
+        this.#mut_head = 0;
+        this.#mut_tail = 0;
+        this.#mut_size = 0;
+        this.#mut_capacity = initialCapacity;
+        for (const value of initialValues) {
+            this.enqueue(value);
+        }
     }
-  }
-  /**
-   * @internal
-   * Resizes the circular buffer when it becomes full.
-   * Doubles the capacity and reorganizes elements to maintain queue order.
-   */
-  #resize() {
-    const newCapacity = asUint32(this.#mut_capacity * 2);
-    const newBuffer = Array.from(
-      { length: newCapacity },
-      () => void 0
-    );
-    for (const i of range(asSafeUint(this.#mut_size))) {
-      const sourceIndex = (this.#mut_head + i) % this.#mut_capacity;
-      newBuffer[i] = this.#mut_buffer[sourceIndex];
+    #resize() {
+        const newCapacity = asUint32(this.#mut_capacity * 2);
+        const newBuffer = Array.from({ length: newCapacity }, () => undefined);
+        for (const i of range(asSafeUint(this.#mut_size))) {
+            const sourceIndex = (this.#mut_head + i) % this.#mut_capacity;
+            newBuffer[i] = this.#mut_buffer[sourceIndex];
+        }
+        this.#mut_buffer = newBuffer;
+        this.#mut_head = 0;
+        this.#mut_tail = this.#mut_size;
+        this.#mut_capacity = newCapacity;
     }
-    this.#mut_buffer = newBuffer;
-    this.#mut_head = 0;
-    this.#mut_tail = this.#mut_size;
-    this.#mut_capacity = newCapacity;
-  }
-  /** @inheritdoc */
-  get isEmpty() {
-    return this.#mut_size === 0;
-  }
-  /** @inheritdoc */
-  get size() {
-    return asUint32(this.#mut_size);
-  }
-  /**
-   * Removes and returns the element at the front of the queue (FIFO).
-   *
-   * This operation removes the element that was added earliest (first-in) and
-   * returns it. If the queue is empty, returns `Optional.none`. The operation
-   * is guaranteed to be O(1) and does not require any array shifting or
-   * copying.
-   *
-   * **Time Complexity:** O(1) - constant time operation **Space Complexity:**
-   * O(1) - no additional memory allocation
-   *
-   * @returns An Optional containing the removed element, or `Optional.none` if
-   *   the queue is empty.
-   */
-  dequeue() {
-    if (this.isEmpty) {
-      return none;
+    get isEmpty() {
+        return this.#mut_size === 0;
     }
-    const element = this.#mut_buffer[this.#mut_head];
-    this.#mut_buffer[this.#mut_head] = void 0;
-    this.#mut_head = (this.#mut_head + 1) % this.#mut_capacity;
-    this.#mut_size -= 1;
-    return some(element);
-  }
-  /**
-   * Adds an element to the back of the queue (FIFO).
-   *
-   * This operation adds the element to the end of the queue, where it will be
-   * the last to be dequeued (first-in, first-out ordering). The operation is
-   * amortized O(1), meaning it's O(1) for most operations with occasional O(n)
-   * when the buffer needs resizing.
-   *
-   * **Time Complexity:** O(1) amortized - O(n) only when buffer resize is
-   * needed **Space Complexity:** O(1) - constant additional memory per element
-   *
-   * **Buffer Resizing:** When the internal buffer becomes full, it
-   * automatically doubles in size and reorganizes elements to maintain the
-   * circular buffer structure.
-   *
-   * @param value The element to add to the back of the queue.
-   */
-  enqueue(value) {
-    if (this.#mut_size === this.#mut_capacity) {
-      this.#resize();
+    get size() {
+        return asUint32(this.#mut_size);
+    }
+    dequeue() {
+        if (this.isEmpty) {
+            return Optional.none;
+        }
+        const element = this.#mut_buffer[this.#mut_head];
+        this.#mut_buffer[this.#mut_head] = undefined;
+        this.#mut_head = (this.#mut_head + 1) % this.#mut_capacity;
+        this.#mut_size -= 1;
+        return Optional.some(element);
+    }
+    enqueue(value) {
+        if (this.#mut_size === this.#mut_capacity) {
+            this.#resize();
+        }
+        this.#mut_buffer[this.#mut_tail] = value;
+        this.#mut_tail = (this.#mut_tail + 1) % this.#mut_capacity;
+        this.#mut_size += 1;
     }
-    this.#mut_buffer[this.#mut_tail] = value;
-    this.#mut_tail = (this.#mut_tail + 1) % this.#mut_capacity;
-    this.#mut_size += 1;
-  }
 }
-const createQueue = (initialValues) => new QueueClass(initialValues);
-export { createQueue };
-//# sourceMappingURL=queue.mjs.map
+export const createQueue = (initialValues) => new QueueClass(initialValues);
+//# sourceMappingURL=queue.mjs.map

package/dist/collections/queue.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"queue.mjs","sources":["../../src/collections/queue.mts"],"sourcesContent":["import { Optional } from '../functional/index.mjs';\nimport { range } from '../iterator/index.mjs';\nimport { asSafeUint, asUint32 } from '../number/index.mjs';\nimport { type SizeType } from '../types.mjs';\n\n/*\n Interface for a high-performance queue with FIFO (First-In, First-Out)\n * behavior.\n \n This interface defines a mutable queue data structure where elements are\n * added to the back and removed from the front, maintaining the order in which\n * they were added. The implementation uses a circular buffer for optimal\n * performance, providing O(1) operations for both enqueue and dequeue\n * operations.\n \n FIFO Behavior:\n \n - enqueue: Adds elements to the back of the queue\n * - dequeue: Removes and returns elements from the front of the queue\n * - Elements are processed in the exact order they were added\n \n Performance Characteristics:\n \n - Enqueue: O(1) amortized (O(n) when buffer needs resizing)\n * - Dequeue: O(1) always\n * - Size/isEmpty: O(1) always\n * - Memory efficient with automatic garbage collection of removed elements\n \n Use Cases:\n \n - Task scheduling and job queues\n * - Breadth-first search algorithms\n * - Event processing systems\n * - Producer-consumer patterns\n * - Buffer management for streaming data\n \n @template T The type of elements stored in the queue.\n /\nexport type Queue<T> = Readonly<{\n /\n Checks if the queue is empty.\n \n @example\n \n ```ts\n * const queue = createQueue<number>();\n \n assert.isTrue(queue.isEmpty);\n \n assert.isTrue(queue.size === 0);\n \n queue.enqueue(1);\n \n queue.enqueue(2);\n \n assert.isFalse(queue.isEmpty);\n \n assert.isTrue(queue.size === 2);\n \n assert.deepStrictEqual(queue.dequeue(), Optional.some(1));\n \n assert.deepStrictEqual(queue.dequeue(), Optional.some(2));\n \n assert.deepStrictEqual(queue.dequeue(), Optional.none);\n \n const seededQueue = createQueue(['first', 'second']);\n \n assert.isTrue(seededQueue.size === 2);\n \n assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));\n \n assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('second'));\n * ```\n /\n isEmpty: boolean;\n\n /\n The number of elements in the queue.\n \n @example\n \n ```ts\n * const queue = createQueue<number>();\n \n assert.isTrue(queue.isEmpty);\n \n assert.isTrue(queue.size === 0);\n \n queue.enqueue(1);\n \n queue.enqueue(2);\n \n assert.isFalse(queue.isEmpty);\n \n assert.isTrue(queue.size === 2);\n \n assert.deepStrictEqual(queue.dequeue(), Optional.some(1));\n \n assert.deepStrictEqual(queue.dequeue(), Optional.some(2));\n \n assert.deepStrictEqual(queue.dequeue(), Optional.none);\n \n const seededQueue = createQueue(['first', 'second']);\n \n assert.isTrue(seededQueue.size === 2);\n \n assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));\n \n assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('second'));\n * ```\n /\n size: SizeType.Arr;\n\n /\n Removes and returns the element at the front of the queue.\n \n @example\n \n ```ts\n * const queue = createQueue<number>();\n \n assert.isTrue(queue.isEmpty);\n \n assert.isTrue(queue.size === 0);\n \n queue.enqueue(1);\n \n queue.enqueue(2);\n \n assert.isFalse(queue.isEmpty);\n \n assert.isTrue(queue.size === 2);\n \n assert.deepStrictEqual(queue.dequeue(), Optional.some(1));\n \n assert.deepStrictEqual(queue.dequeue(), Optional.some(2));\n \n assert.deepStrictEqual(queue.dequeue(), Optional.none);\n \n const seededQueue = createQueue(['first', 'second']);\n \n assert.isTrue(seededQueue.size === 2);\n \n assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));\n \n assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('second'));\n * ```\n \n @returns The element at the front of the queue, or `Optional.none` if the\n * queue is empty.\n /\n dequeue: () => Optional<T>;\n\n /\n Adds an element to the back of the queue.\n \n @example\n \n ```ts\n * const queue = createQueue<number>();\n \n assert.isTrue(queue.isEmpty);\n \n assert.isTrue(queue.size === 0);\n \n queue.enqueue(1);\n \n queue.enqueue(2);\n \n assert.isFalse(queue.isEmpty);\n \n assert.isTrue(queue.size === 2);\n \n assert.deepStrictEqual(queue.dequeue(), Optional.some(1));\n \n assert.deepStrictEqual(queue.dequeue(), Optional.some(2));\n \n assert.deepStrictEqual(queue.dequeue(), Optional.none);\n \n const seededQueue = createQueue(['first', 'second']);\n \n assert.isTrue(seededQueue.size === 2);\n \n assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));\n \n assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('second'));\n * ```\n \n @param value The element to add.\n /\n enqueue: (value: T) => void;\n}>;\n\n/\n Class implementation for a queue with FIFO (First-In, First-Out) behavior\n * using a circular buffer. This implementation provides O(1) enqueue and\n * dequeue operations by using a fixed-size buffer with head and tail pointers\n * that wrap around when they reach the buffer boundary.\n \n The circular buffer automatically resizes when it becomes full, ensuring that\n * the queue can grow to accommodate any number of elements while maintaining\n * efficient operations.\n \n @template T The type of elements in the queue.\n * @implements Queue\n /\nclass QueueClass<T> implements Queue<T> {\n /* @internal Initial capacity for new queues. /\n static readonly #INITIAL_CAPACITY = 8;\n\n /* @internal Circular buffer to store queue elements. /\n #mut_buffer: (T \| undefined)[];\n\n /* @internal Index of the first element (front of queue). /\n #mut_head: number;\n\n /* @internal Index where the next element will be added (back of queue). /\n #mut_tail: number;\n\n /* @internal Current number of elements in the queue. /\n #mut_size: number;\n\n /* @internal Current capacity of the buffer. /\n #mut_capacity: number;\n\n /\n Constructs a new QueueClass instance.\n \n @param initialValues Optional initial values to populate the queue.\n /\n constructor(initialValues: readonly T[] = []) {\n const initialCapacity = asUint32(\n Math.max(QueueClass.#INITIAL_CAPACITY, initialValues.length 2),\n );\n\n this.#mut_buffer = Array.from<unknown, T \| undefined>(\n { length: initialCapacity },\n () => undefined,\n );\n\n this.#mut_head = 0;\n\n this.#mut_tail = 0;\n\n this.#mut_size = 0;\n\n this.#mut_capacity = initialCapacity;\n\n // Add initial values\n for (const value of initialValues) {\n this.enqueue(value);\n }\n }\n\n /*\n @internal\n * Resizes the circular buffer when it becomes full.\n * Doubles the capacity and reorganizes elements to maintain queue order.\n /\n #resize(): void {\n const newCapacity = asUint32(this.#mut_capacity 2);\n\n const newBuffer = Array.from<unknown, T \| undefined>(\n { length: newCapacity },\n () => undefined,\n );\n\n // Copy elements in order from head to tail\n for (const i of range(asSafeUint(this.#mut_size))) {\n const sourceIndex = (this.#mut_head + i) % this.#mut_capacity;\n\n newBuffer[i] = this.#mut_buffer[sourceIndex];\n }\n\n this.#mut_buffer = newBuffer;\n\n this.#mut_head = 0;\n\n this.#mut_tail = this.#mut_size;\n\n this.#mut_capacity = newCapacity;\n }\n\n /** @inheritdoc /\n get isEmpty(): boolean {\n return this.#mut_size === 0;\n }\n\n /* @inheritdoc /\n get size(): SizeType.Arr {\n return asUint32(this.#mut_size);\n }\n\n /\n Removes and returns the element at the front of the queue (FIFO).\n \n This operation removes the element that was added earliest (first-in) and\n * returns it. If the queue is empty, returns `Optional.none`. The operation\n * is guaranteed to be O(1) and does not require any array shifting or\n * copying.\n \n Time Complexity: O(1) - constant time operation Space Complexity:\n * O(1) - no additional memory allocation\n \n @returns An Optional containing the removed element, or `Optional.none` if\n * the queue is empty.\n /\n dequeue(): Optional<T> {\n if (this.isEmpty) {\n return Optional.none;\n }\n\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n const element = this.#mut_buffer[this.#mut_head]!;\n\n this.#mut_buffer[this.#mut_head] = undefined; // Clear reference for garbage collection\n\n this.#mut_head = (this.#mut_head + 1) % this.#mut_capacity;\n\n this.#mut_size -= 1;\n\n return Optional.some(element);\n }\n\n /\n Adds an element to the back of the queue (FIFO).\n \n This operation adds the element to the end of the queue, where it will be\n * the last to be dequeued (first-in, first-out ordering). The operation is\n * amortized O(1), meaning it's O(1) for most operations with occasional O(n)\n * when the buffer needs resizing.\n \n Time Complexity: O(1) amortized - O(n) only when buffer resize is\n * needed Space Complexity: O(1) - constant additional memory per element\n \n Buffer Resizing: When the internal buffer becomes full, it\n * automatically doubles in size and reorganizes elements to maintain the\n * circular buffer structure.\n \n @param value The element to add to the back of the queue.\n /\n enqueue(value: T): void {\n // Resize if buffer is full\n if (this.#mut_size === this.#mut_capacity) {\n this.#resize();\n }\n\n this.#mut_buffer[this.#mut_tail] = value;\n\n this.#mut_tail = (this.#mut_tail + 1) % this.#mut_capacity;\n\n this.#mut_size += 1;\n }\n}\n\n/\n Creates a new Queue instance with FIFO (First-In, First-Out) behavior using a\n * high-performance circular buffer.\n \n This factory function creates an optimized queue implementation that\n * maintains excellent performance characteristics for both enqueue and dequeue\n * operations. The underlying circular buffer automatically resizes to\n * accommodate growing workloads while providing predictable O(1) operations.\n \n Implementation Features:\n \n - O(1) enqueue operations (amortized - occasionally O(n) when resizing)\n * - O(1) dequeue operations (always)\n * - Automatic buffer resizing - starts at 8 elements, doubles when full\n * - Memory efficient - garbage collects removed elements immediately\n * - Circular buffer design - eliminates need for array shifting operations\n \n Performance Benefits:\n \n - No array copying during normal operations\n * - Minimal memory allocation overhead\n * - Predictable performance under high load\n * - Efficient memory usage with automatic cleanup\n \n @example\n \n ```ts\n * const queue = createQueue<number>();\n \n assert.isTrue(queue.isEmpty);\n \n assert.isTrue(queue.size === 0);\n \n queue.enqueue(1);\n \n queue.enqueue(2);\n \n assert.isFalse(queue.isEmpty);\n \n assert.isTrue(queue.size === 2);\n \n assert.deepStrictEqual(queue.dequeue(), Optional.some(1));\n \n assert.deepStrictEqual(queue.dequeue(), Optional.some(2));\n \n assert.deepStrictEqual(queue.dequeue(), Optional.none);\n \n const seededQueue = createQueue(['first', 'second']);\n \n assert.isTrue(seededQueue.size === 2);\n \n assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('first'));\n \n assert.deepStrictEqual(seededQueue.dequeue(), Optional.some('second'));\n * ```\n \n @template T The type of elements stored in the queue.\n * @param initialValues Optional array of initial elements to populate the\n * queue. Elements will be dequeued in the same order they appear in the\n * array. If provided, the initial buffer capacity will be at least twice the\n * array length.\n * @returns A new Queue instance optimized for high-performance FIFO operations.\n */\nexport const createQueue = <T,>(initialValues?: readonly T[]): Queue<T> =>\n new QueueClass<T>(initialValues);\n"],"names":["Optional.none","Optional.some"],"mappings":"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"}
1	+ {"version":3,"file":"queue.mjs","sourceRoot":"","sources":["../../src/collections/queue.mts"],"names":[],"mappings":"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"}