Fmt

Author: hugoalh

SECURITY.md

@@ -4,7 +4,8 @@
 
 | **Versions** | **Release Date** | **Long Term Support Date** | **End Of Life Date** |
 |:-:|:-:|:-:|:-:|
-| v4.X.X | 2024-01-11 | 2024-01-11 | *Unknown* |
+| v5.X.X | 2025-07-22 | 2025-07-22 | *Unknown* |
+| v4.X.X | 2024-01-11 | 2024-01-11 | 2026-02-28 |
 
 > [!NOTE]
 > - The date format is according to the specification ISO 8601.

assert.ts

@@ -0,0 +1,67 @@
+import { notDeepStrictEqual } from "node:assert";
+/**
+ * Collect unique elements into the collector.
+ */
+export class UniqueCollector<T> {
+	get [Symbol.toStringTag](): string {
+		return "UniqueCollector";
+	}
+	#bin: Set<T> = new Set<T>();
+	#count: bigint = 0n;
+	[Symbol.iterator](): SetIterator<T> {
+		return this.#bin[Symbol.iterator]();
+	}
+	/**
+	 * Collect the element into the collector.
+	 * @param {T} o Element that need to collect.
+	 * @returns {boolean} Whether the element is collected (i.e.: element is unique).
+	 */
+	collect(o: T): boolean {
+		this.#count += 1n;
+		const isExist: boolean = this.has(o);
+		if (!isExist) {
+			this.#bin.add(o);
+		}
+		return !isExist;
+	}
+	/**
+	 * Get the number of collects in the collector.
+	 * @returns {bigint}
+	 */
+	getCount(): bigint {
+		return this.#count;
+	}
+	/**
+	 * Get the number of unique elements in the collector.
+	 * @returns {number}
+	 */
+	getSize(): number {
+		return this.#bin.size;
+	}
+	/**
+	 * Check whether the collector has the element.
+	 * @param {T} o Element that need to check.
+	 * @returns {boolean} Determine result.
+	 */
+	has(o: T): boolean {
+		for (const value of this.values()) {
+			if (value === o) {
+				return true;
+			}
+			try {
+				notDeepStrictEqual(value, o);
+			} catch {
+				return true;
+			}
+		}
+		return false;
+	}
+	/**
+	 * Iterate the elements in the collector.
+	 * @returns {SetIterator<T>}
+	 */
+	values(): SetIterator<T> {
+		return this.#bin.values();
+	}
+}
+export default UniqueCollector;

collector.ts

@@ -1,10 +1,9 @@
 {
 	"$schema": "https://deno.land/x/deno/cli/schemas/config-file.v1.json",
 	"name": "@hugoalh/unique-array",
-	"version": "4.1.1",
+	"version": "5.0.0",
 	"exports": {
-		"./assert": "./assert.ts",
-		"./uniquify": "./uniquify.ts",
+		"./collector": "./collector.ts",
 		".": "./mod.ts"
 	},
 	"imports": {

jsr.jsonc

@@ -1,29 +1,25 @@
 import { deepStrictEqual } from "node:assert";
-import {
-	uniqueArray,
-	uniqueIterate,
-	uniqueIterateSync
-} from "./uniquify.ts";
-Deno.test("Array 0/0", { permissions: "none" }, () => {
+import { uniqueArray } from "./mod.ts";
+Deno.test("0/0", { permissions: "none" }, () => {
 	deepStrictEqual(uniqueArray([]), []);
 });
-Deno.test("Array 1/2 1", { permissions: "none" }, () => {
+Deno.test("1/2 1", { permissions: "none" }, () => {
 	deepStrictEqual(uniqueArray([
 		{ type: { id: "_ETGENUS" } },
 		{ type: { id: "_ETGENUS" } }
 	]), [
 		{ type: { id: "_ETGENUS" } }
 	]);
 });
-Deno.test("Array 1/2 2", { permissions: "none" }, () => {
+Deno.test("1/2 2", { permissions: "none" }, () => {
 	deepStrictEqual(uniqueArray([
 		new Set([1, 2, 3]),
 		new Set([1, 2, 3])
 	]), [
 		new Set([1, 2, 3])
 	]);
 });
-Deno.test("Array 2/2", { permissions: "none" }, () => {
+Deno.test("2/2", { permissions: "none" }, () => {
 	deepStrictEqual(uniqueArray([
 		{
 			id: "_1p7ZED73OF98VbT1SzSkjn",
@@ -52,7 +48,7 @@ Deno.test("Array 2/2", { permissions: "none" }, () => {
 		}
 	]);
 });
-Deno.test("Array 2/3 1", { permissions: "none" }, () => {
+Deno.test("2/3 1", { permissions: "none" }, () => {
 	deepStrictEqual(uniqueArray([
 		{ foo: "bar" },
 		{ foo: "bar" },
@@ -62,7 +58,7 @@ Deno.test("Array 2/3 1", { permissions: "none" }, () => {
 		{ bar: "gaz" }
 	]);
 });
-Deno.test("Array 2/3 2", { permissions: "none" }, () => {
+Deno.test("2/3 2", { permissions: "none" }, () => {
 	deepStrictEqual(uniqueArray([
 		new Set([1, 2, 3]),
 		new Set([1, 2]),
@@ -72,12 +68,9 @@ Deno.test("Array 2/3 2", { permissions: "none" }, () => {
 		new Set([1, 2])
 	]);
 });
-Deno.test("Array 1/6", { permissions: "none" }, () => {
+Deno.test("1/6", { permissions: "none" }, () => {
 	deepStrictEqual(uniqueArray([{}, {}, {}, {}, {}, {}]), [{}]);
 });
-Deno.test("Array 6/6", { permissions: "none" }, () => {
+Deno.test("6/6", { permissions: "none" }, () => {
 	deepStrictEqual(uniqueArray([1, 2n, "3", false, true, null]), [1, 2n, "3", false, true, null]);
 });
-Deno.test("Iterate 5/10", { permissions: "none" }, async () => {
-	deepStrictEqual(await Array.fromAsync(uniqueIterate([1, 2, 3], new Set([1, 2, 3, 4]).values(), uniqueIterateSync([1, 4, 5]))), [1, 2, 3, 4, 5]);
-});

uniquify.test.ts renamed to mod.test.ts

@@ -1,7 +1,31 @@
-export { isArrayUnique } from "./assert.ts";
-export {
-	default,
-	uniqueArray,
-	uniqueIterate,
-	uniqueIterateSync
-} from "./uniquify.ts";
+import { UniqueCollector } from "./collector.ts";
+export { UniqueCollector } from "./collector.ts";
+/**
+ * Return unique array elements without any duplicated elements.
+ * @template {unknown} T
+ * @param {...readonly T[]} items Arrays that need to have unique elements.
+ * @returns {T[]} An array with unique elements.
+ * @example
+ * ```ts
+ * uniqueArray([{ foo: "bar" }, { foo: "bar" }, { bar: "gaz" }]);
+ * //=> [{ foo: "bar" }, { bar: "gaz" }]
+ * ```
+ */
+export function uniqueArray<T>(...items: readonly (readonly T[])[]): T[] {
+	const collector: UniqueCollector<T> = new UniqueCollector<T>();
+	for (const item of items) {
+		for (const element of item) {
+			collector.collect(element);
+		}
+	}
+	return Array.from(collector.values());
+}
+export default uniqueArray;
+/**
+ * Determine whether the array is contain unique elements.
+ * @param {readonly unknown[]} item Item that need to determine.
+ * @returns {boolean} Determine result.
+ */
+export function isArrayUnique(item: readonly unknown[]): boolean {
+	return (item.length === uniqueArray(item).length);
+}