@monstermann/set 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Michael Ostermann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+<div align="center">
+
+<h1>set</h1>
+
+**Functional utilities for sets.**
+
+[Documentation](https://MichaelOstermann.github.io/set)
+
+</div>

package/dist/Set/add.d.ts

@@ -0,0 +1,28 @@
+//#region src/Set/add.d.ts
+/**
+ * ```ts
+ * function Set.add(target, value)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.add(Set.create([1, 2]), 3); // Set([1, 2, 3])
+ * Set.add(Set.create([1, 2]), 2); // Set([1, 2])
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2]), Set.add(3)); // Set([1, 2, 3])
+ * pipe(Set.create([1, 2]), Set.add(2)); // Set([1, 2])
+ * ```
+ */
+declare const add: {
+  <T>(value: NoInfer<T>): (target: Set<T>) => Set<T>;
+  <T>(value: NoInfer<T>): (target: ReadonlySet<T>) => ReadonlySet<T>;
+  <T>(target: Set<T>, value: NoInfer<T>): Set<T>;
+  <T>(target: ReadonlySet<T>, value: NoInfer<T>): ReadonlySet<T>;
+};
+//#endregion
+export { add };

package/dist/Set/add.js

@@ -0,0 +1,32 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneSet } from "@monstermann/remmi";
+
+//#region src/Set/add.ts
+/**
+* ```ts
+* function Set.add(target, value)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.add(Set.create([1, 2]), 3); // Set([1, 2, 3])
+* Set.add(Set.create([1, 2]), 2); // Set([1, 2])
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2]), Set.add(3)); // Set([1, 2, 3])
+* pipe(Set.create([1, 2]), Set.add(2)); // Set([1, 2])
+* ```
+*/
+const add = dfdlT((target, value) => {
+	if (target.has(value)) return target;
+	target = cloneSet(target);
+	target.add(value);
+	return target;
+}, 2);
+
+//#endregion
+export { add };

package/dist/Set/addAll.d.ts

@@ -0,0 +1,28 @@
+//#region src/Set/addAll.d.ts
+/**
+ * ```ts
+ * function Set.addAll(target, values)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.addAll(Set.create([1, 2]), [3, 4]); // Set([1, 2, 3, 4])
+ * Set.addAll(Set.create([1, 2]), [2, 3]); // Set([1, 2, 3])
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2]), Set.addAll([3, 4])); // Set([1, 2, 3, 4])
+ * pipe(Set.create([1, 2]), Set.addAll([2, 3])); // Set([1, 2, 3])
+ * ```
+ */
+declare const addAll: {
+  <T>(values: Iterable<NoInfer<T>>): (target: Set<T>) => Set<T>;
+  <T>(values: Iterable<NoInfer<T>>): (target: ReadonlySet<T>) => ReadonlySet<T>;
+  <T>(target: Set<T>, values: Iterable<NoInfer<T>>): Set<T>;
+  <T>(target: ReadonlySet<T>, values: Iterable<NoInfer<T>>): ReadonlySet<T>;
+};
+//#endregion
+export { addAll };

package/dist/Set/addAll.js

@@ -0,0 +1,35 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneSet } from "@monstermann/remmi";
+
+//#region src/Set/addAll.ts
+/**
+* ```ts
+* function Set.addAll(target, values)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.addAll(Set.create([1, 2]), [3, 4]); // Set([1, 2, 3, 4])
+* Set.addAll(Set.create([1, 2]), [2, 3]); // Set([1, 2, 3])
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2]), Set.addAll([3, 4])); // Set([1, 2, 3, 4])
+* pipe(Set.create([1, 2]), Set.addAll([2, 3])); // Set([1, 2, 3])
+* ```
+*/
+const addAll = dfdlT((target, values) => {
+	let result;
+	for (const value of values) {
+		if (target.has(value)) continue;
+		result ??= cloneSet(target);
+		result.add(value);
+	}
+	return result ?? target;
+}, 2);
+
+//#endregion
+export { addAll };

package/dist/Set/addOr.d.ts

@@ -0,0 +1,26 @@
+//#region src/Set/addOr.d.ts
+/**
+ * ```ts
+ * function Set.addOr(target, value, or)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.addOr(Set.create([1, 2]), 3, null); // Set([1, 2, 3])
+ * Set.addOr(Set.create([1, 2]), 2, null); // null
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2]), Set.addOr(3, null)); // Set([1, 2, 3])
+ * pipe(Set.create([1, 2]), Set.addOr(2, null)); // null
+ * ```
+ */
+declare const addOr: {
+  <T, U>(value: NoInfer<T>, or: U): (target: ReadonlySet<T>) => Set<T> | U;
+  <T, U>(target: ReadonlySet<T>, value: NoInfer<T>, or: U): Set<T> | U;
+};
+//#endregion
+export { addOr };

package/dist/Set/addOr.js

@@ -0,0 +1,32 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneSet } from "@monstermann/remmi";
+
+//#region src/Set/addOr.ts
+/**
+* ```ts
+* function Set.addOr(target, value, or)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.addOr(Set.create([1, 2]), 3, null); // Set([1, 2, 3])
+* Set.addOr(Set.create([1, 2]), 2, null); // null
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2]), Set.addOr(3, null)); // Set([1, 2, 3])
+* pipe(Set.create([1, 2]), Set.addOr(2, null)); // null
+* ```
+*/
+const addOr = dfdlT((target, value, or) => {
+	if (target.has(value)) return or;
+	const result = cloneSet(target);
+	result.add(value);
+	return result;
+}, 3);
+
+//#endregion
+export { addOr };

package/dist/Set/addOrElse.d.ts

@@ -0,0 +1,33 @@
+//#region src/Set/addOrElse.d.ts
+/**
+ * ```ts
+ * function Set.addOrElse(target, value, orElse)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.addOrElse(Set.create([1, 2]), 3, (set) => set.size); // Set([1, 2, 3])
+ * Set.addOrElse(Set.create([1, 2]), 2, (set) => set.size); // 2
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(
+ *     Set.create([1, 2]),
+ *     Set.addOrElse(3, (set) => set.size),
+ * ); // Set([1, 2, 3])
+ *
+ * pipe(
+ *     Set.create([1, 2]),
+ *     Set.addOrElse(2, (set) => set.size),
+ * ); // 2
+ * ```
+ */
+declare const addOrElse: {
+  <T, U>(value: NoInfer<T>, orElse: (target: ReadonlySet<NoInfer<T>>) => U): (target: ReadonlySet<T>) => Set<T> | U;
+  <T, U>(target: ReadonlySet<T>, value: NoInfer<T>, orElse: (target: ReadonlySet<NoInfer<T>>) => U): Set<T> | U;
+};
+//#endregion
+export { addOrElse };

package/dist/Set/addOrElse.js

@@ -0,0 +1,39 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneSet } from "@monstermann/remmi";
+
+//#region src/Set/addOrElse.ts
+/**
+* ```ts
+* function Set.addOrElse(target, value, orElse)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.addOrElse(Set.create([1, 2]), 3, (set) => set.size); // Set([1, 2, 3])
+* Set.addOrElse(Set.create([1, 2]), 2, (set) => set.size); // 2
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(
+*     Set.create([1, 2]),
+*     Set.addOrElse(3, (set) => set.size),
+* ); // Set([1, 2, 3])
+*
+* pipe(
+*     Set.create([1, 2]),
+*     Set.addOrElse(2, (set) => set.size),
+* ); // 2
+* ```
+*/
+const addOrElse = dfdlT((target, value, orElse) => {
+	if (target.has(value)) return orElse(target);
+	const result = cloneSet(target);
+	result.add(value);
+	return result;
+}, 3);
+
+//#endregion
+export { addOrElse };

package/dist/Set/addOrThrow.d.ts

@@ -0,0 +1,26 @@
+//#region src/Set/addOrThrow.d.ts
+/**
+ * ```ts
+ * function Set.addOrThrow(target, value)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.addOrThrow(Set.create([1, 2]), 3); // Set([1, 2, 3])
+ * Set.addOrThrow(Set.create([1, 2]), 2); // throws FnError
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2]), Set.addOrThrow(3)); // Set([1, 2, 3])
+ * pipe(Set.create([1, 2]), Set.addOrThrow(2)); // throws FnError
+ * ```
+ */
+declare const addOrThrow: {
+  <T>(value: NoInfer<T>): (target: ReadonlySet<T>) => Set<T>;
+  <T>(target: ReadonlySet<T>, value: NoInfer<T>): Set<T>;
+};
+//#endregion
+export { addOrThrow };

package/dist/Set/addOrThrow.js

@@ -0,0 +1,32 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneSet } from "@monstermann/remmi";
+
+//#region src/Set/addOrThrow.ts
+/**
+* ```ts
+* function Set.addOrThrow(target, value)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.addOrThrow(Set.create([1, 2]), 3); // Set([1, 2, 3])
+* Set.addOrThrow(Set.create([1, 2]), 2); // throws FnError
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2]), Set.addOrThrow(3)); // Set([1, 2, 3])
+* pipe(Set.create([1, 2]), Set.addOrThrow(2)); // throws FnError
+* ```
+*/
+const addOrThrow = dfdlT((target, value) => {
+	if (target.has(value)) throw new Error("Set.addOrThrow: Value already exists.");
+	const result = cloneSet(target);
+	result.add(value);
+	return result;
+}, 2);
+
+//#endregion
+export { addOrThrow };

package/dist/Set/clone.d.ts

@@ -0,0 +1,26 @@
+//#region src/Set/clone.d.ts
+/**
+ * ```ts
+ * function Set.clone(target)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * const original = Set.create([1, 2, 3]);
+ * const copy = Set.clone(original); // Set { 1, 2, 3 }
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * const original = Set.create([1, 2, 3]);
+ * const copy = pipe(original, Set.clone()); // Set { 1, 2, 3 }
+ * ```
+ */
+declare const clone: {
+  (): <T>(target: ReadonlySet<T>) => Set<T>;
+  <T>(target: ReadonlySet<T>): Set<T>;
+};
+//#endregion
+export { clone };

package/dist/Set/clone.js

@@ -0,0 +1,27 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneSet } from "@monstermann/remmi";
+
+//#region src/Set/clone.ts
+/**
+* ```ts
+* function Set.clone(target)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* const original = Set.create([1, 2, 3]);
+* const copy = Set.clone(original); // Set { 1, 2, 3 }
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* const original = Set.create([1, 2, 3]);
+* const copy = pipe(original, Set.clone()); // Set { 1, 2, 3 }
+* ```
+*/
+const clone = dfdlT(cloneSet, 1);
+
+//#endregion
+export { clone };

package/dist/Set/compact.d.ts

@@ -0,0 +1,31 @@
+import { NonNil } from "./internals/types.js";
+
+//#region src/Set/compact.d.ts
+
+/**
+ * ```ts
+ * function Set.compact(target)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.compact(Set.create([1, null, 2, undefined])); // Set([1, 2])
+ * Set.compact(Set.create([1, 2, 3])); // Set([1, 2, 3])
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, null, 2, undefined]), Set.compact()); // Set([1, 2])
+ * pipe(Set.create([1, 2, 3]), Set.compact()); // Set([1, 2, 3])
+ * ```
+ */
+declare const compact: {
+  <T>(): (target: Set<T>) => Set<NonNil<T>>;
+  <T>(): (target: ReadonlySet<T>) => ReadonlySet<NonNil<T>>;
+  <T>(target: Set<T>): Set<NonNil<T>>;
+  <T>(target: ReadonlySet<T>): ReadonlySet<NonNil<T>>;
+};
+//#endregion
+export { compact };

package/dist/Set/compact.js

@@ -0,0 +1,33 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneSet } from "@monstermann/remmi";
+
+//#region src/Set/compact.ts
+/**
+* ```ts
+* function Set.compact(target)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.compact(Set.create([1, null, 2, undefined])); // Set([1, 2])
+* Set.compact(Set.create([1, 2, 3])); // Set([1, 2, 3])
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, null, 2, undefined]), Set.compact()); // Set([1, 2])
+* pipe(Set.create([1, 2, 3]), Set.compact()); // Set([1, 2, 3])
+* ```
+*/
+const compact = dfdlT((target) => {
+	if (!target.has(null) && !target.has(void 0)) return target;
+	target = cloneSet(target);
+	target.delete(null);
+	target.delete(void 0);
+	return target;
+}, 1);
+
+//#endregion
+export { compact };

package/dist/Set/difference.d.ts

@@ -0,0 +1,26 @@
+//#region src/Set/difference.d.ts
+/**
+ * ```ts
+ * function Set.difference(target, source)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.difference(Set.create([1, 2, 3]), Set.create([2, 3, 4])); // Set([1])
+ * Set.difference(Set.create([1, 2]), Set.create([3, 4])); // Set([1, 2])
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2, 3]), Set.difference(Set.create([2, 3, 4]))); // Set([1])
+ * pipe(Set.create([1, 2]), Set.difference(Set.create([3, 4]))); // Set([1, 2])
+ * ```
+ */
+declare const difference: {
+  <T, U>(source: Set<U>): (target: Set<T>) => Set<T>;
+  <T, U>(target: Set<T>, source: Set<U>): Set<T>;
+};
+//#endregion
+export { difference };

package/dist/Set/difference.js

@@ -0,0 +1,37 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/difference.ts
+/**
+* ```ts
+* function Set.difference(target, source)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.difference(Set.create([1, 2, 3]), Set.create([2, 3, 4])); // Set([1])
+* Set.difference(Set.create([1, 2]), Set.create([3, 4])); // Set([1, 2])
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3]), Set.difference(Set.create([2, 3, 4]))); // Set([1])
+* pipe(Set.create([1, 2]), Set.difference(Set.create([3, 4]))); // Set([1, 2])
+* ```
+*/
+const difference = dfdlT((target, source) => {
+	if (source.size === 0) return target;
+	for (const value of target) if (source.has(value)) {
+		const result = /* @__PURE__ */ new Set();
+		for (const value$1 of target) {
+			if (source.has(value$1)) continue;
+			result.add(value$1);
+		}
+		return result;
+	}
+	return target;
+}, 2);
+
+//#endregion
+export { difference };

package/dist/Set/forEach.d.ts

@@ -0,0 +1,29 @@
+//#region src/Set/forEach.d.ts
+/**
+ * ```ts
+ * function Set.forEach(target, fn)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.forEach(Set.create([1, 2, 3]), (value) => console.log(value)); // Set([1, 2, 3])
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(
+ *     Set.create([1, 2, 3]),
+ *     Set.forEach((value) => console.log(value)),
+ * ); // Set([1, 2, 3])
+ * ```
+ */
+declare const forEach: {
+  <T>(fn: (value: NoInfer<T>, target: ReadonlySet<NoInfer<T>>) => unknown): (target: Set<T>) => Set<T>;
+  <T>(fn: (value: NoInfer<T>, target: ReadonlySet<NoInfer<T>>) => unknown): (target: ReadonlySet<T>) => ReadonlySet<T>;
+  <T>(target: Set<T>, fn: (value: NoInfer<T>, target: ReadonlySet<NoInfer<T>>) => unknown): Set<T>;
+  <T>(target: ReadonlySet<T>, fn: (value: NoInfer<T>, target: ReadonlySet<NoInfer<T>>) => unknown): ReadonlySet<T>;
+};
+//#endregion
+export { forEach };

package/dist/Set/forEach.js

@@ -0,0 +1,30 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/forEach.ts
+/**
+* ```ts
+* function Set.forEach(target, fn)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.forEach(Set.create([1, 2, 3]), (value) => console.log(value)); // Set([1, 2, 3])
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(
+*     Set.create([1, 2, 3]),
+*     Set.forEach((value) => console.log(value)),
+* ); // Set([1, 2, 3])
+* ```
+*/
+const forEach = dfdlT((target, fn) => {
+	for (const value of target) fn(value, target);
+	return target;
+}, 2);
+
+//#endregion
+export { forEach };

package/dist/Set/has.d.ts

@@ -0,0 +1,26 @@
+//#region src/Set/has.d.ts
+/**
+ * ```ts
+ * function Set.has(target, value)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.has(Set.create([1, 2, 3]), 2); // true
+ * Set.has(Set.create([1, 2, 3]), 4); // false
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2, 3]), Set.has(2)); // true
+ * pipe(Set.create([1, 2, 3]), Set.has(4)); // false
+ * ```
+ */
+declare const has: {
+  <T>(value: NoInfer<T>): (target: ReadonlySet<T>) => boolean;
+  <T>(target: ReadonlySet<T>, value: NoInfer<T>): boolean;
+};
+//#endregion
+export { has };

package/dist/Set/has.js

@@ -0,0 +1,28 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/has.ts
+/**
+* ```ts
+* function Set.has(target, value)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.has(Set.create([1, 2, 3]), 2); // true
+* Set.has(Set.create([1, 2, 3]), 4); // false
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3]), Set.has(2)); // true
+* pipe(Set.create([1, 2, 3]), Set.has(4)); // false
+* ```
+*/
+const has = dfdlT((target, value) => {
+	return target.has(value);
+}, 2);
+
+//#endregion
+export { has };

package/dist/Set/hasAll.d.ts

@@ -0,0 +1,26 @@
+//#region src/Set/hasAll.d.ts
+/**
+ * ```ts
+ * function Set.hasAll(target, values)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.hasAll(Set.create([1, 2, 3]), [1, 2]); // true
+ * Set.hasAll(Set.create([1, 2, 3]), [1, 4]); // false
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2, 3]), Set.hasAll([1, 2])); // true
+ * pipe(Set.create([1, 2, 3]), Set.hasAll([1, 4])); // false
+ * ```
+ */
+declare const hasAll: {
+  <T>(values: Iterable<NoInfer<T>>): (target: ReadonlySet<T>) => boolean;
+  <T>(target: ReadonlySet<T>, values: Iterable<NoInfer<T>>): boolean;
+};
+//#endregion
+export { hasAll };