@monstermann/set 0.2.0 → 0.3.0

package/dist/Set/isSupersetOf.d.mts

@@ -1,24 +1,32 @@
 //#region src/Set/isSupersetOf.d.ts
 /**
+ * # isSupersetOf
+ *
  * ```ts
- * function Set.isSupersetOf(target, source)
+ * function Set.isSupersetOf<T>(
+ *     target: ReadonlySet<T>,
+ *     source: ReadonlySet<NoInfer<T>>,
+ * ): boolean
  * ```
  *
- * Example
+ * Returns `true` if the target set contains all values from the source set, `false` otherwise.
  *
- * ```ts
+ * ## Example
+ *
+ * ```ts [data-first]
  * import { Set } from "@monstermann/set";
  *
  * Set.isSupersetOf(Set.create([1, 2, 3]), Set.create([1, 2])); // true
  * Set.isSupersetOf(Set.create([1, 2, 3]), Set.create([1, 4])); // false
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Set } from "@monstermann/set";
  *
  * pipe(Set.create([1, 2, 3]), Set.isSupersetOf(Set.create([1, 2]))); // true
  * pipe(Set.create([1, 2, 3]), Set.isSupersetOf(Set.create([1, 4]))); // false
  * ```
+ *
  */
 declare const isSupersetOf: {
   <T>(source: ReadonlySet<NoInfer<T>>): (target: ReadonlySet<T>) => boolean;

package/dist/Set/isSupersetOf.mjs

@@ -2,25 +2,33 @@ import { dfdlT } from "@monstermann/dfdl";
 
 //#region src/Set/isSupersetOf.ts
 /**
+* # isSupersetOf
+*
 * ```ts
-* function Set.isSupersetOf(target, source)
+* function Set.isSupersetOf<T>(
+*     target: ReadonlySet<T>,
+*     source: ReadonlySet<NoInfer<T>>,
+* ): boolean
 * ```
 *
-* Example
+* Returns `true` if the target set contains all values from the source set, `false` otherwise.
 *
-* ```ts
+* ## Example
+*
+* ```ts [data-first]
 * import { Set } from "@monstermann/set";
 *
 * Set.isSupersetOf(Set.create([1, 2, 3]), Set.create([1, 2])); // true
 * Set.isSupersetOf(Set.create([1, 2, 3]), Set.create([1, 4])); // false
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Set } from "@monstermann/set";
 *
 * pipe(Set.create([1, 2, 3]), Set.isSupersetOf(Set.create([1, 2]))); // true
 * pipe(Set.create([1, 2, 3]), Set.isSupersetOf(Set.create([1, 4]))); // false
 * ```
+*
 */
 const isSupersetOf = dfdlT((target, source) => {
 	if (target.size < source.size) return false;

package/dist/Set/mapEach.d.mts

@@ -1,19 +1,29 @@
 //#region src/Set/mapEach.d.ts
 /**
+ * # mapEach
+ *
  * ```ts
- * function Set.mapEach(target, fn)
+ * function Set.mapEach<T, U>(
+ *     target: ReadonlySet<T>,
+ *     fn: (
+ *         value: NoInfer<T>,
+ *         target: ReadonlySet<NoInfer<T>>,
+ *     ) => U,
+ * ): ReadonlySet<U>
  * ```
  *
- * Example
+ * Returns a new set with each value transformed by the mapping function.
  *
- * ```ts
+ * ## Example
+ *
+ * ```ts [data-first]
  * import { Set } from "@monstermann/set";
  *
  * Set.mapEach(Set.create([1, 2, 3]), (x) => x * 2); // Set([2, 4, 6])
  * Set.mapEach(Set.create(["a", "b"]), (x) => x.toUpperCase()); // Set(['A', 'B'])
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Set } from "@monstermann/set";
  *
  * pipe(
@@ -26,6 +36,7 @@
  *     Set.mapEach((x) => x.toUpperCase()),
  * ); // Set(['A', 'B'])
  * ```
+ *
  */
 declare const mapEach: {
   <T, U>(fn: (value: NoInfer<T>, target: ReadonlySet<NoInfer<T>>) => U): (target: Set<T>) => Set<U>;

package/dist/Set/mapEach.mjs

@@ -2,20 +2,30 @@ import { dfdlT } from "@monstermann/dfdl";
 
 //#region src/Set/mapEach.ts
 /**
+* # mapEach
+*
 * ```ts
-* function Set.mapEach(target, fn)
+* function Set.mapEach<T, U>(
+*     target: ReadonlySet<T>,
+*     fn: (
+*         value: NoInfer<T>,
+*         target: ReadonlySet<NoInfer<T>>,
+*     ) => U,
+* ): ReadonlySet<U>
 * ```
 *
-* Example
+* Returns a new set with each value transformed by the mapping function.
 *
-* ```ts
+* ## Example
+*
+* ```ts [data-first]
 * import { Set } from "@monstermann/set";
 *
 * Set.mapEach(Set.create([1, 2, 3]), (x) => x * 2); // Set([2, 4, 6])
 * Set.mapEach(Set.create(["a", "b"]), (x) => x.toUpperCase()); // Set(['A', 'B'])
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Set } from "@monstermann/set";
 *
 * pipe(
@@ -28,6 +38,7 @@ import { dfdlT } from "@monstermann/dfdl";
 *     Set.mapEach((x) => x.toUpperCase()),
 * ); // Set(['A', 'B'])
 * ```
+*
 */
 const mapEach = dfdlT((target, fn) => {
 	let hasChanges = false;

package/dist/Set/remove.d.mts

@@ -1,24 +1,32 @@
 //#region src/Set/remove.d.ts
 /**
+ * # remove
+ *
  * ```ts
- * function Set.remove(target, value)
+ * function Set.remove<T>(
+ *     target: ReadonlySet<T>,
+ *     value: NoInfer<T>,
+ * ): ReadonlySet<T>
  * ```
  *
- * Example
+ * Returns a set with the value removed. If the value doesn't exist in the set, returns the original set unchanged.
  *
- * ```ts
+ * ## Example
+ *
+ * ```ts [data-first]
  * import { Set } from "@monstermann/set";
  *
  * Set.remove(Set.create([1, 2, 3]), 2); // Set([1, 3])
  * Set.remove(Set.create([1, 2, 3]), 4); // Set([1, 2, 3])
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Set } from "@monstermann/set";
  *
  * pipe(Set.create([1, 2, 3]), Set.remove(2)); // Set([1, 3])
  * pipe(Set.create([1, 2, 3]), Set.remove(4)); // Set([1, 2, 3])
  * ```
+ *
  */
 declare const remove: {
   <T>(value: NoInfer<T>): (target: Set<T>) => Set<T>;

package/dist/Set/remove.mjs

@@ -3,25 +3,33 @@ import { cloneSet } from "@monstermann/remmi";
 
 //#region src/Set/remove.ts
 /**
+* # remove
+*
 * ```ts
-* function Set.remove(target, value)
+* function Set.remove<T>(
+*     target: ReadonlySet<T>,
+*     value: NoInfer<T>,
+* ): ReadonlySet<T>
 * ```
 *
-* Example
+* Returns a set with the value removed. If the value doesn't exist in the set, returns the original set unchanged.
 *
-* ```ts
+* ## Example
+*
+* ```ts [data-first]
 * import { Set } from "@monstermann/set";
 *
 * Set.remove(Set.create([1, 2, 3]), 2); // Set([1, 3])
 * Set.remove(Set.create([1, 2, 3]), 4); // Set([1, 2, 3])
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Set } from "@monstermann/set";
 *
 * pipe(Set.create([1, 2, 3]), Set.remove(2)); // Set([1, 3])
 * pipe(Set.create([1, 2, 3]), Set.remove(4)); // Set([1, 2, 3])
 * ```
+*
 */
 const remove = dfdlT((target, value) => {
 	if (!target.has(value)) return target;

package/dist/Set/removeAll.d.mts

@@ -1,24 +1,32 @@
 //#region src/Set/removeAll.d.ts
 /**
+ * # removeAll
+ *
  * ```ts
- * function Set.removeAll(target, values)
+ * function Set.removeAll<T>(
+ *     target: ReadonlySet<T>,
+ *     values: Iterable<NoInfer<T>>,
+ * ): ReadonlySet<T>
  * ```
  *
- * Example
+ * Returns a set with all values from the iterable removed. Values that don't exist in the set are skipped.
  *
- * ```ts
+ * ## Example
+ *
+ * ```ts [data-first]
  * import { Set } from "@monstermann/set";
  *
  * Set.removeAll(Set.create([1, 2, 3, 4]), [2, 3]); // Set([1, 4])
  * Set.removeAll(Set.create([1, 2, 3]), [4, 5]); // Set([1, 2, 3])
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Set } from "@monstermann/set";
  *
  * pipe(Set.create([1, 2, 3, 4]), Set.removeAll([2, 3])); // Set([1, 4])
  * pipe(Set.create([1, 2, 3]), Set.removeAll([4, 5])); // Set([1, 2, 3])
  * ```
+ *
  */
 declare const removeAll: {
   <T>(values: Iterable<NoInfer<T>>): (target: Set<T>) => Set<T>;

package/dist/Set/removeAll.mjs

@@ -3,25 +3,33 @@ import { cloneSet } from "@monstermann/remmi";
 
 //#region src/Set/removeAll.ts
 /**
+* # removeAll
+*
 * ```ts
-* function Set.removeAll(target, values)
+* function Set.removeAll<T>(
+*     target: ReadonlySet<T>,
+*     values: Iterable<NoInfer<T>>,
+* ): ReadonlySet<T>
 * ```
 *
-* Example
+* Returns a set with all values from the iterable removed. Values that don't exist in the set are skipped.
 *
-* ```ts
+* ## Example
+*
+* ```ts [data-first]
 * import { Set } from "@monstermann/set";
 *
 * Set.removeAll(Set.create([1, 2, 3, 4]), [2, 3]); // Set([1, 4])
 * Set.removeAll(Set.create([1, 2, 3]), [4, 5]); // Set([1, 2, 3])
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Set } from "@monstermann/set";
 *
 * pipe(Set.create([1, 2, 3, 4]), Set.removeAll([2, 3])); // Set([1, 4])
 * pipe(Set.create([1, 2, 3]), Set.removeAll([4, 5])); // Set([1, 2, 3])
 * ```
+*
 */
 const removeAll = dfdlT((target, values) => {
 	let result;

package/dist/Set/size.d.mts

@@ -1,24 +1,31 @@
 //#region src/Set/size.d.ts
 /**
+ * # size
+ *
  * ```ts
- * function Set.size(target)
+ * function Set.size<T extends ReadonlySet<unknown>>(
+ *     target: T,
+ * ): number
  * ```
  *
- * Example
+ * Returns the number of values in the set.
  *
- * ```ts
+ * ## Example
+ *
+ * ```ts [data-first]
  * import { Set } from "@monstermann/set";
  *
  * Set.size(Set.create([1, 2, 3])); // 3
  * Set.size(Set.create()); // 0
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Set } from "@monstermann/set";
  *
  * pipe(Set.create([1, 2, 3]), Set.size()); // 3
  * pipe(Set.create(), Set.size()); // 0
  * ```
+ *
  */
 declare const size: {
   (): <T extends ReadonlySet<unknown>>(target: T) => number;

package/dist/Set/size.mjs

@@ -2,25 +2,32 @@ import { dfdlT } from "@monstermann/dfdl";
 
 //#region src/Set/size.ts
 /**
+* # size
+*
 * ```ts
-* function Set.size(target)
+* function Set.size<T extends ReadonlySet<unknown>>(
+*     target: T,
+* ): number
 * ```
 *
-* Example
+* Returns the number of values in the set.
 *
-* ```ts
+* ## Example
+*
+* ```ts [data-first]
 * import { Set } from "@monstermann/set";
 *
 * Set.size(Set.create([1, 2, 3])); // 3
 * Set.size(Set.create()); // 0
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Set } from "@monstermann/set";
 *
 * pipe(Set.create([1, 2, 3]), Set.size()); // 3
 * pipe(Set.create(), Set.size()); // 0
 * ```
+*
 */
 const size = dfdlT((target) => {
 	return target.size;

package/dist/Set/symmetricDifference.d.mts

@@ -1,24 +1,32 @@
 //#region src/Set/symmetricDifference.d.ts
 /**
+ * # symmetricDifference
+ *
  * ```ts
- * function Set.symmetricDifference(target, source)
+ * function Set.symmetricDifference<T, U>(
+ *     target: Set<T>,
+ *     source: Set<U>,
+ * ): Set<T | U>
  * ```
  *
- * Example
+ * Returns a set containing values that exist in either set but not in both.
  *
- * ```ts
+ * ## Example
+ *
+ * ```ts [data-first]
  * import { Set } from "@monstermann/set";
  *
  * Set.symmetricDifference(Set.create([1, 2, 3]), Set.create([3, 4, 5])); // Set([1, 2, 4, 5])
  * Set.symmetricDifference(Set.create([1, 2]), Set.create([3, 4])); // Set([1, 2, 3, 4])
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Set } from "@monstermann/set";
  *
  * pipe(Set.create([1, 2, 3]), Set.symmetricDifference(Set.create([3, 4, 5]))); // Set([1, 2, 4, 5])
  * pipe(Set.create([1, 2]), Set.symmetricDifference(Set.create([3, 4]))); // Set([1, 2, 3, 4])
  * ```
+ *
  */
 declare const symmetricDifference: {
   <T, U>(source: Set<U>): (target: Set<T>) => Set<T | U>;

package/dist/Set/symmetricDifference.mjs

@@ -2,25 +2,33 @@ import { dfdlT } from "@monstermann/dfdl";
 
 //#region src/Set/symmetricDifference.ts
 /**
+* # symmetricDifference
+*
 * ```ts
-* function Set.symmetricDifference(target, source)
+* function Set.symmetricDifference<T, U>(
+*     target: Set<T>,
+*     source: Set<U>,
+* ): Set<T | U>
 * ```
 *
-* Example
+* Returns a set containing values that exist in either set but not in both.
 *
-* ```ts
+* ## Example
+*
+* ```ts [data-first]
 * import { Set } from "@monstermann/set";
 *
 * Set.symmetricDifference(Set.create([1, 2, 3]), Set.create([3, 4, 5])); // Set([1, 2, 4, 5])
 * Set.symmetricDifference(Set.create([1, 2]), Set.create([3, 4])); // Set([1, 2, 3, 4])
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Set } from "@monstermann/set";
 *
 * pipe(Set.create([1, 2, 3]), Set.symmetricDifference(Set.create([3, 4, 5]))); // Set([1, 2, 4, 5])
 * pipe(Set.create([1, 2]), Set.symmetricDifference(Set.create([3, 4]))); // Set([1, 2, 3, 4])
 * ```
+*
 */
 const symmetricDifference = dfdlT((target, source) => {
 	if (source.size === 0) return target;

package/dist/Set/toArray.d.mts

@@ -1,24 +1,29 @@
 //#region src/Set/toArray.d.ts
 /**
+ * # toArray
+ *
  * ```ts
- * function Set.toArray(target)
+ * function Set.toArray<T>(target: ReadonlySet<T>): T[]
  * ```
  *
- * Example
+ * Converts the set to an array.
  *
- * ```ts
+ * ## Example
+ *
+ * ```ts [data-first]
  * import { Set } from "@monstermann/set";
  *
  * Set.toArray(Set.create([1, 2, 3])); // [1, 2, 3]
  * Set.toArray(Set.create(["a", "b"])); // ['a', 'b']
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Set } from "@monstermann/set";
  *
  * pipe(Set.create([1, 2, 3]), Set.toArray()); // [1, 2, 3]
  * pipe(Set.create(["a", "b"]), Set.toArray()); // ['a', 'b']
  * ```
+ *
  */
 declare const toArray: {
   (): <T>(target: ReadonlySet<T>) => T[];

package/dist/Set/toArray.mjs

@@ -2,25 +2,30 @@ import { dfdlT } from "@monstermann/dfdl";
 
 //#region src/Set/toArray.ts
 /**
+* # toArray
+*
 * ```ts
-* function Set.toArray(target)
+* function Set.toArray<T>(target: ReadonlySet<T>): T[]
 * ```
 *
-* Example
+* Converts the set to an array.
 *
-* ```ts
+* ## Example
+*
+* ```ts [data-first]
 * import { Set } from "@monstermann/set";
 *
 * Set.toArray(Set.create([1, 2, 3])); // [1, 2, 3]
 * Set.toArray(Set.create(["a", "b"])); // ['a', 'b']
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Set } from "@monstermann/set";
 *
 * pipe(Set.create([1, 2, 3]), Set.toArray()); // [1, 2, 3]
 * pipe(Set.create(["a", "b"]), Set.toArray()); // ['a', 'b']
 * ```
+*
 */
 const toArray = dfdlT((target) => {
 	return Array.from(target);

package/dist/Set/union.d.mts

@@ -1,24 +1,32 @@
 //#region src/Set/union.d.ts
 /**
+ * # union
+ *
  * ```ts
- * function Set.union(target, source)
+ * function Set.union<T, U>(
+ *     target: Set<T>,
+ *     source: Set<U>,
+ * ): Set<T | U>
  * ```
  *
- * Example
+ * Returns a set containing all values from both sets.
  *
- * ```ts
+ * ## Example
+ *
+ * ```ts [data-first]
  * import { Set } from "@monstermann/set";
  *
  * Set.union(Set.create([1, 2]), Set.create([2, 3, 4])); // Set([1, 2, 3, 4])
  * Set.union(Set.create([1, 2]), Set.create([3, 4])); // Set([1, 2, 3, 4])
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Set } from "@monstermann/set";
  *
  * pipe(Set.create([1, 2]), Set.union(Set.create([2, 3, 4]))); // Set([1, 2, 3, 4])
  * pipe(Set.create([1, 2]), Set.union(Set.create([3, 4]))); // Set([1, 2, 3, 4])
  * ```
+ *
  */
 declare const union: {
   <T, U>(source: Set<U>): (target: Set<T>) => Set<T | U>;

package/dist/Set/union.mjs

@@ -2,25 +2,33 @@ import { dfdlT } from "@monstermann/dfdl";
 
 //#region src/Set/union.ts
 /**
+* # union
+*
 * ```ts
-* function Set.union(target, source)
+* function Set.union<T, U>(
+*     target: Set<T>,
+*     source: Set<U>,
+* ): Set<T | U>
 * ```
 *
-* Example
+* Returns a set containing all values from both sets.
 *
-* ```ts
+* ## Example
+*
+* ```ts [data-first]
 * import { Set } from "@monstermann/set";
 *
 * Set.union(Set.create([1, 2]), Set.create([2, 3, 4])); // Set([1, 2, 3, 4])
 * Set.union(Set.create([1, 2]), Set.create([3, 4])); // Set([1, 2, 3, 4])
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Set } from "@monstermann/set";
 *
 * pipe(Set.create([1, 2]), Set.union(Set.create([2, 3, 4]))); // Set([1, 2, 3, 4])
 * pipe(Set.create([1, 2]), Set.union(Set.create([3, 4]))); // Set([1, 2, 3, 4])
 * ```
+*
 */
 const union = dfdlT((target, source) => {
 	if (source.size === 0) return target;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@monstermann/set",
     "type": "module",
-    "version": "0.2.0",
+    "version": "0.3.0",
     "description": "Functional utilities for sets.",
     "author": "Michael Ostermann <michaelostermann@me.com>",
     "license": "MIT",
@@ -34,6 +34,6 @@
     },
     "dependencies": {
         "@monstermann/dfdl": "^0.1.0",
-        "@monstermann/remmi": "^0.0.0"
+        "@monstermann/remmi": "^0.1.0"
     }
 }

package/dist/Set/addOr.d.mts

@@ -1,28 +0,0 @@
-//#region src/Set/addOr.d.ts
-/**
- * ```ts
- * function Set.addOr(target, value, or)
- * ```
- *
- * Example
- *
- * ```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 };