@develia/commons 0.4.25 → 0.5.0

package/dist/uuid.js

@@ -0,0 +1,129 @@
+/** Versions 1 to 8 with the RFC variant, plus the Nil and Max UUIDs of RFC 9562 sections 5.9 and 5.10. */
+const PATTERN = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|0{8}-0{4}-0{4}-0{4}-0{12}|f{8}-f{4}-f{4}-f{4}-f{12})$/i;
+/** Largest Unix timestamp in milliseconds that fits in the 48 bits of a version 7 UUID. */
+const MAX_V7_MILLISECONDS = 0xffffffffffff;
+/**
+ * Immutable universally unique identifier (RFC 9562), kept in lowercase canonical form,
+ * such as `019a4f8b-4bae-7d2e-9f10-4a5b6c7d8e9f`.
+ *
+ * It serializes to its string with `JSON.stringify`, so DTOs carry it as text; read those
+ * strings back with {@link Uuid.parse} or {@link Uuid.parseOrThrow}.
+ */
+export default class Uuid {
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Generates a version 4 UUID from 122 random bits of a cryptographically secure source.
+     *
+     * Unlike `crypto.randomUUID()`, it also works in browser contexts that are not secure, such as
+     * a development site served over HTTP.
+     */
+    static generateV4() {
+        const bytes = new Uint8Array(16);
+        globalThis.crypto.getRandomValues(bytes);
+        return Uuid.createWithVersion(bytes, 4);
+    }
+    /**
+     * Generates a version 7 UUID: a 48-bit Unix timestamp in milliseconds followed by 74 random bits
+     * from a cryptographically secure source, so identifiers sort by creation time.
+     *
+     * Identifiers generated within the same millisecond keep no particular order among themselves.
+     *
+     * @param date Moment the UUID encodes; the current time when omitted.
+     * @throws {RangeError} If the date is invalid, before the Unix epoch or beyond the 48-bit range.
+     */
+    static generateV7(date = new Date()) {
+        const milliseconds = date.getTime();
+        if (!Number.isInteger(milliseconds) || milliseconds < 0 || milliseconds > MAX_V7_MILLISECONDS) {
+            throw new RangeError('A version 7 UUID can only encode a valid date from the Unix epoch on.');
+        }
+        const bytes = new Uint8Array(16);
+        globalThis.crypto.getRandomValues(bytes);
+        let remaining = milliseconds;
+        for (let index = 5; index >= 0; index--) {
+            bytes[index] = remaining % 256;
+            remaining = Math.floor(remaining / 256);
+        }
+        return Uuid.createWithVersion(bytes, 7);
+    }
+    /**
+     * Checks if a value is a UUID in canonical form, in any letter case: one of RFC 9562 versions 1 to 8,
+     * or its Nil UUID (all zeros) or Max UUID (all ones).
+     *
+     * It returns a plain boolean rather than a type guard: a string that is not a UUID is still a
+     * string, which a guard would narrow to `never`.
+     */
+    static isValid(value) {
+        return typeof value === 'string' && PATTERN.test(value);
+    }
+    /**
+     * Reads a UUID in canonical form, in any letter case, as {@link Uuid.isValid} accepts it.
+     *
+     * @returns The UUID, or `null` when the value is not one.
+     */
+    static parse(value) {
+        if (typeof value !== 'string' || !Uuid.isValid(value)) {
+            return null;
+        }
+        return new Uuid(value.toLowerCase());
+    }
+    /**
+     * Reads a UUID in canonical form, in any letter case.
+     *
+     * @throws {SyntaxError} If the value is not a UUID.
+     */
+    static parseOrThrow(value) {
+        const uuid = Uuid.parse(value);
+        if (uuid === null) {
+            throw new SyntaxError(`Invalid UUID "${value}".`);
+        }
+        return uuid;
+    }
+    /**
+     * Returns the RFC 9562 version, from 1 to 8, or 0 for the Nil UUID and 15 for the Max UUID.
+     */
+    getVersion() {
+        return Number.parseInt(this.value.charAt(14), 16);
+    }
+    /**
+     * Returns the moment a version 7 UUID encodes, with millisecond precision.
+     *
+     * @returns The moment, or `null` for other versions.
+     */
+    getDate() {
+        if (this.getVersion() !== 7) {
+            return null;
+        }
+        const milliseconds = Number.parseInt(this.value.slice(0, 8) + this.value.slice(9, 13), 16);
+        return new Date(milliseconds);
+    }
+    equals(other) {
+        return this.value === other.value;
+    }
+    /**
+     * Returns the UUID in lowercase canonical form.
+     */
+    toString() {
+        return this.value;
+    }
+    toJSON() {
+        return this.value;
+    }
+    /**
+     * Sets the version and the RFC 9562 variant bits of 16 bytes and wraps them as a UUID.
+     *
+     * @param bytes Exactly 16 bytes; only the version and variant bits are overwritten.
+     * @param version From 1 to 8.
+     */
+    static createWithVersion(bytes, version) {
+        bytes[6] = (bytes[6] & 0x0f) | (version << 4);
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        let hex = '';
+        for (const byte of bytes) {
+            hex += byte.toString(16).padStart(2, '0');
+        }
+        return new Uuid(`${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`);
+    }
+}
+//# sourceMappingURL=uuid.js.map

package/dist/uuid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.js","sourceRoot":"","sources":["../src/uuid.ts"],"names":[],"mappings":"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","sourcesContent":["import {Nullable} from './types.js';\n\n/** Versions 1 to 8 with the RFC variant, plus the Nil and Max UUIDs of RFC 9562 sections 5.9 and 5.10. */\nconst PATTERN = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|0{8}-0{4}-0{4}-0{4}-0{12}|f{8}-f{4}-f{4}-f{4}-f{12})$/i;\n\n/** Largest Unix timestamp in milliseconds that fits in the 48 bits of a version 7 UUID. */\nconst MAX_V7_MILLISECONDS = 0xffffffffffff;\n\n/**\n * Immutable universally unique identifier (RFC 9562), kept in lowercase canonical form,\n * such as `019a4f8b-4bae-7d2e-9f10-4a5b6c7d8e9f`.\n *\n * It serializes to its string with `JSON.stringify`, so DTOs carry it as text; read those\n * strings back with {@link Uuid.parse} or {@link Uuid.parseOrThrow}.\n */\nexport default class Uuid {\n    private readonly value: string;\n\n    private constructor(value: string) {\n        this.value = value;\n    }\n\n    /**\n     * Generates a version 4 UUID from 122 random bits of a cryptographically secure source.\n     *\n     * Unlike `crypto.randomUUID()`, it also works in browser contexts that are not secure, such as\n     * a development site served over HTTP.\n     */\n    static generateV4(): Uuid {\n        const bytes = new Uint8Array(16);\n        globalThis.crypto.getRandomValues(bytes);\n\n        return Uuid.createWithVersion(bytes, 4);\n    }\n\n    /**\n     * Generates a version 7 UUID: a 48-bit Unix timestamp in milliseconds followed by 74 random bits\n     * from a cryptographically secure source, so identifiers sort by creation time.\n     *\n     * Identifiers generated within the same millisecond keep no particular order among themselves.\n     *\n     * @param date Moment the UUID encodes; the current time when omitted.\n     * @throws {RangeError} If the date is invalid, before the Unix epoch or beyond the 48-bit range.\n     */\n    static generateV7(date: Date = new Date()): Uuid {\n        const milliseconds = date.getTime();\n        if (!Number.isInteger(milliseconds) || milliseconds < 0 || milliseconds > MAX_V7_MILLISECONDS) {\n            throw new RangeError('A version 7 UUID can only encode a valid date from the Unix epoch on.');\n        }\n\n        const bytes = new Uint8Array(16);\n        globalThis.crypto.getRandomValues(bytes);\n        let remaining = milliseconds;\n        for (let index = 5; index >= 0; index--) {\n            bytes[index] = remaining % 256;\n            remaining = Math.floor(remaining / 256);\n        }\n\n        return Uuid.createWithVersion(bytes, 7);\n    }\n\n    /**\n     * Checks if a value is a UUID in canonical form, in any letter case: one of RFC 9562 versions 1 to 8,\n     * or its Nil UUID (all zeros) or Max UUID (all ones).\n     *\n     * It returns a plain boolean rather than a type guard: a string that is not a UUID is still a\n     * string, which a guard would narrow to `never`.\n     */\n    static isValid(value: unknown): boolean {\n        return typeof value === 'string' && PATTERN.test(value);\n    }\n\n    /**\n     * Reads a UUID in canonical form, in any letter case, as {@link Uuid.isValid} accepts it.\n     *\n     * @returns The UUID, or `null` when the value is not one.\n     */\n    static parse(value: unknown): Nullable<Uuid> {\n        if (typeof value !== 'string' || !Uuid.isValid(value)) {\n            return null;\n        }\n\n        return new Uuid(value.toLowerCase());\n    }\n\n    /**\n     * Reads a UUID in canonical form, in any letter case.\n     *\n     * @throws {SyntaxError} If the value is not a UUID.\n     */\n    static parseOrThrow(value: string): Uuid {\n        const uuid = Uuid.parse(value);\n        if (uuid === null) {\n            throw new SyntaxError(`Invalid UUID \"${value}\".`);\n        }\n\n        return uuid;\n    }\n\n    /**\n     * Returns the RFC 9562 version, from 1 to 8, or 0 for the Nil UUID and 15 for the Max UUID.\n     */\n    getVersion(): number {\n        return Number.parseInt(this.value.charAt(14), 16);\n    }\n\n    /**\n     * Returns the moment a version 7 UUID encodes, with millisecond precision.\n     *\n     * @returns The moment, or `null` for other versions.\n     */\n    getDate(): Nullable<Date> {\n        if (this.getVersion() !== 7) {\n            return null;\n        }\n\n        const milliseconds = Number.parseInt(this.value.slice(0, 8) + this.value.slice(9, 13), 16);\n        return new Date(milliseconds);\n    }\n\n    equals(other: Uuid): boolean {\n        return this.value === other.value;\n    }\n\n    /**\n     * Returns the UUID in lowercase canonical form.\n     */\n    toString(): string {\n        return this.value;\n    }\n\n    toJSON(): string {\n        return this.value;\n    }\n\n    /**\n     * Sets the version and the RFC 9562 variant bits of 16 bytes and wraps them as a UUID.\n     *\n     * @param bytes Exactly 16 bytes; only the version and variant bits are overwritten.\n     * @param version From 1 to 8.\n     */\n    private static createWithVersion(bytes: Uint8Array, version: number): Uuid {\n        bytes[6] = (bytes[6] & 0x0f) | (version << 4);\n        bytes[8] = (bytes[8] & 0x3f) | 0x80;\n\n        let hex = '';\n        for (const byte of bytes) {\n            hex += byte.toString(16).padStart(2, '0');\n        }\n\n        return new Uuid(`${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`);\n    }\n}\n"]}

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@develia/commons",
-  "version": "0.4.25",
+  "version": "0.5.0",
   "author": {
     "name": "Antonio Gil Espinosa",
     "email": "antonio.gil.espinosa@gmail.com",
     "url": "https://antoniogilespinosa.com"
   },
   "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -17,6 +20,7 @@
     "./parse": "./dist/parse.js",
     "./string": "./dist/string.js",
     "./math": "./dist/math.js",
+    "./uuid": "./dist/uuid.js",
     "./collections": "./dist/collections/index.js",
     "./browser": "./dist/browser/index.js"
   },

package/src/array.ts

@@ -49,6 +49,25 @@ export function chunk<T>(array: Array<T>, size: number): Array<Array<T>> {
     return result;
 }
 
+/**
+ * A copy of the array with the element at one index moved to another, the others shifting to make room; the array
+ * stays as it was. An index out of the array leaves the copy in the same order.
+ * @template T
+ * @param {ReadonlyArray<T>} array - The array.
+ * @param {number} fromIndex - Index of the element to move.
+ * @param {number} toIndex - Index the element ends at.
+ * @return {Array<T>} The copy, in the new order.
+ */
+export function moveItem<T>(array: ReadonlyArray<T>, fromIndex: number, toIndex: number): Array<T> {
+    const result = [...array];
+    if (fromIndex < 0 || fromIndex >= result.length || toIndex < 0 || toIndex >= result.length) {
+        return result;
+    }
+    const [item] = result.splice(fromIndex, 1);
+    result.splice(toIndex, 0, item as T);
+    return result;
+}
+
 /**
  * Removes all elements from the array, mutating it.
  * @template T

package/src/async-pool-executor.ts

@@ -7,11 +7,11 @@ type QueuedTask<T> = {
     reject: (reason?: any) => void;
 };
 
-function normalizeMaxConcurrency(value: number): number {
+/** @throws {RangeError} When it is not a positive integer. */
+function assertValidMaxConcurrency(value: number): void {
     if (!Number.isInteger(value) || value < 1) {
         throw new RangeError("maxConcurrency must be a positive integer");
     }
-    return value;
 }
 
 function normalizeCheckInterval(value: number): number {
@@ -26,7 +26,8 @@ export default class AsyncPoolExecutor {
     }
 
     set maxConcurrency(value: number) {
-        this._maxConcurrency = normalizeMaxConcurrency(value);
+        assertValidMaxConcurrency(value);
+        this._maxConcurrency = value;
 
     }
 
@@ -41,7 +42,8 @@ export default class AsyncPoolExecutor {
      * @param {number} [checkInterval=50] - The interval, in milliseconds, to check for capacity to run new tasks. Defaults to 50 ms.
      */
     constructor(maxConcurrency: number, checkInterval: number = 50) {
-        this._maxConcurrency = normalizeMaxConcurrency(maxConcurrency);
+        assertValidMaxConcurrency(maxConcurrency);
+        this._maxConcurrency = maxConcurrency;
         this._checkIntervalMs = normalizeCheckInterval(checkInterval);
         this._activeTasks = 0;
     }
@@ -94,12 +96,10 @@ export default class AsyncPoolExecutor {
 
 
     /**
-     * Waits until all tasks (both queued and active) are completed.
-     * This method resolves only when there are no pending tasks.
-     *
-     * @return {Promise<void>} A promise that resolves when all tasks are complete.
+     * Waits until the queue is empty and no task is running, checking every check interval. It does not stop the
+     * executor: tasks submitted meanwhile are run and waited for too.
      */
-    public async shutdown(): Promise<void> {
+    public async drain(): Promise<void> {
         while (this._taskQueue.length > 0 || this._activeTasks > 0) {
             await delay(this._checkIntervalMs);
         }

package/src/browser/form-utilities.ts

@@ -125,13 +125,13 @@ function _appendFormDataValue(formData: FormData, key: string, value: any): void
             _appendFormDataValue(formData, `${key}[${index}]`, value[index]);
         }
     } else if (value !== null && typeof value === 'object') {
-        _objectToFormData(value, formData, key);
+        _appendToFormData(value, formData, key);
     } else {
         formData.append(key, value);
     }
 }
 
-function _objectToFormData(data: Record<string, any>, formData: FormData, parentKey: string = ''): FormData {
+function _appendToFormData(data: Record<string, any>, formData: FormData, parentKey: string = ''): FormData {
     for (const key in data) {
         if (Object.prototype.hasOwnProperty.call(data, key)) {
             _appendFormDataValue(formData, parentKey ? `${parentKey}[${key}]` : key, data[key]);
@@ -149,34 +149,5 @@ function _objectToFormData(data: Record<string, any>, formData: FormData, parent
  */
 export function objectToFormData(data: Record<string, any>): FormData {
     let formData = new FormData();
-    return _objectToFormData(data, formData);
+    return _appendToFormData(data, formData);
 }
-
-export function ajaxSubmission(
-    selectorOrElement: HTMLFormElement | string,
-    onSuccess?: Consumer<any>,
-    onFailure?: Consumer<any>
-): void {
-
-    const forms: HTMLFormElement[] = typeof selectorOrElement === 'string'
-            ? Array.from(document.querySelectorAll(selectorOrElement))
-                   .filter(el => el instanceof HTMLFormElement) as HTMLFormElement[]
-            : [selectorOrElement];
-
-    for (const form of forms) {
-        form.addEventListener('submit', async (event) => {
-            event.preventDefault();
-
-            try {
-                let result = await ajaxSubmit(event.currentTarget as HTMLFormElement);
-                if (onSuccess)
-                    onSuccess(result);
-            } catch (e) {
-                if (onFailure)
-                    onFailure(e);
-            }
-
-
-        });
-    }
-}

package/src/browser/geo-location.ts

@@ -33,7 +33,7 @@ function positionToGeoLocation(position: GeolocationPosition): GeoLocation {
     };
 }
 
-function geolocationError(error: GeolocationPositionError): Error {
+function toGeolocationError(error: GeolocationPositionError): Error {
     switch (error.code) {
         case error.PERMISSION_DENIED:
             return new Error('Has denegado el permiso de ubicación.');
@@ -50,7 +50,7 @@ function requestPosition(options: PositionOptions): Promise<GeoLocation> {
     return new Promise((resolve, reject) => {
         navigator.geolocation.getCurrentPosition(
             (position) => resolve(positionToGeoLocation(position)),
-            (error) => reject(geolocationError(error)),
+            (error) => reject(toGeolocationError(error)),
             options,
         );
     });
@@ -87,7 +87,7 @@ async function ensurePermission(): Promise<void> {
                 },
                 (error) => {
                     permission.onchange = null;
-                    reject(geolocationError(error));
+                    reject(toGeolocationError(error));
                 },
                 {timeout: 30000},
             );

package/src/browser/native-bridge.ts

@@ -34,7 +34,7 @@ export default class NativeBridge {
         }
 
         (window as any)[callbackName] = (id: number, error: any, result: any) => {
-            this._callback(id, error, result);
+            this._settlePendingCall(id, error, result);
         };
 
         // Proxy: cualquier propiedad no existente se convierte en call()
@@ -49,7 +49,7 @@ export default class NativeBridge {
     }
 
 
-    private _callback(id: number, error: any, result: any) {
+    private _settlePendingCall(id: number, error: any, result: any) {
 
         const pending = this._pending.get(id);
         if (!pending) {

package/src/cancellable-promise.ts

@@ -36,9 +36,14 @@ export default class CancellablePromise<T> extends Promise<T> {
         }
     }
 
-    static async compete<T>(promises: CancellablePromise<T>[]): Promise<T> {
+    /**
+     * Resolves or rejects as the first of the promises to settle (Promise.race), and cancels all the others, also when
+     * the first one fails.
+     * @throws {Error} When there are no promises.
+     */
+    static async raceAndCancelOthers<T>(promises: CancellablePromise<T>[]): Promise<T> {
         if (promises.length === 0) {
-            throw new Error("No promises to compete.");
+            throw new Error("No promises to race.");
         }
 
         const result = await Promise.race(
@@ -61,7 +66,8 @@ export default class CancellablePromise<T> extends Promise<T> {
         return result.value;
     }
 
-    static async cooperate<T>(promises: CancellablePromise<T>[]): Promise<T[]> {
+    /** Resolves with all the results (Promise.all); when one fails, cancels all of them and rejects with its error. */
+    static async allOrCancelAll<T>(promises: CancellablePromise<T>[]): Promise<T[]> {
         try {
             return await Promise.all(promises);
         } catch (error) {

package/src/clean-url-search-params.ts

@@ -7,12 +7,12 @@ function isRecordParams(params: unknown): params is Record<string, any> {
         typeof (params as any)[Symbol.iterator] !== 'function';
 }
 
-function appendCleanValue(params: URLSearchParams, key: string, value: any): void {
+function appendNonNullishValues(params: URLSearchParams, key: string, value: any): void {
     if (value === null || value === undefined) return;
 
     if (Array.isArray(value)) {
         for (const item of value) {
-            appendCleanValue(params, key, item);
+            appendNonNullishValues(params, key, item);
         }
         return;
     }
@@ -31,7 +31,7 @@ export default class CleanURLSearchParams extends URLSearchParams {
 
         // Filtrar `null` y `undefined` antes de añadirlos a URLSearchParams
         for (const [key, value] of Object.entries(params)) {
-            appendCleanValue(this, key, value);
+            appendNonNullishValues(this, key, value);
         }
     }
 }

package/src/collections/from.ts

@@ -5,21 +5,30 @@ import Order from "../order.js";
 
 
 /**
- * Creates a new From instance from an Iterable or a Supplier of an Iterable.
+ * Creates a new From instance from an Iterable, a Supplier of an Iterable, or the entries of a plain object.
  * @template T - The type of elements in the source.
  * @param {Iterable<T> | Supplier<Iterable<T>>} source - The source data.
- * @returns {From<T> | From<KeyValuePair<any, any>>} A new From instance.
+ * @returns {From<T>} A new From instance.
  * @throws {Error} If source is null or invalid.
  */
-export default function from<T>(source: Iterable<T> | Supplier<Iterable<T>>): From<T> | From<KeyValuePair<any, any>> {
+export default function from<T>(source: Iterable<T> | Supplier<Iterable<T>>): From<T>;
+/**
+ * Creates a new From instance from the enumerable own and inherited properties of a plain object.
+ * @template TValue - The type of the property values.
+ * @param {Record<string, TValue>} source - The source object.
+ * @returns {From<KeyValuePair<string, TValue>>} A From instance of key-value pairs.
+ * @throws {Error} If source is null or invalid.
+ */
+export default function from<TValue>(source: Record<string, TValue>): From<KeyValuePair<string, TValue>>;
+export default function from(source: Iterable<unknown> | Supplier<Iterable<unknown>> | Record<string, unknown>): From<unknown> {
     if (source == null)
         throw new Error("Source is null.");
     if (typeof source === 'function')
-        return From.fn<T>(source);
-    if (typeof source[Symbol.iterator] === 'function') {
-        return From.iterable<T>(source);
+        return From.fn(source);
+    if (Symbol.iterator in source && typeof source[Symbol.iterator] === 'function') {
+        return From.iterable(source as Iterable<unknown>);
     } else if (typeof source === 'object') {
-        return From.object(source);
+        return From.object(source as Record<string, unknown>);
     }
 
     throw new Error("Invalid source.");
@@ -33,11 +42,12 @@ export class From<T> implements Iterable<T> {
 
     /**
      * Creates a From instance from an object's entries.
-     * @param {any} obj - The object to convert to pairs.
-     * @returns {From<KeyValuePair<any, any>>} A From instance of key-value pairs.
+     * @template TValue - The type of the property values.
+     * @param {Record<string, TValue>} obj - The object to convert to pairs.
+     * @returns {From<KeyValuePair<string, TValue>>} A From instance of key-value pairs.
      */
-    public static object(obj: any): From<KeyValuePair<any, any>> {
-        return new From<KeyValuePair<any, any>>(function () {
+    public static object<TValue>(obj: Record<string, TValue>): From<KeyValuePair<string, TValue>> {
+        return new From<KeyValuePair<string, TValue>>(function () {
             return toPairs(obj);
         });
     }
@@ -475,7 +485,7 @@ export class From<T> implements Iterable<T> {
             array.sort((a, b) => {
                 const aValue = mapper(a);
                 const bValue = mapper(b);
-                return aValue > bValue ? 1 : bValue < aValue ? -1 : 0;
+                return aValue > bValue ? -1 : aValue < bValue ? 1 : 0;
             });
         } else {
             throw new Error("invalid order argument");
@@ -703,11 +713,11 @@ export class From<T> implements Iterable<T> {
 
 
     /**
-     * Concatenates two sequences.
+     * The elements of this sequence followed by those of the other, duplicates included, as LINQ's Concat.
      * @param {Iterable<T>} other - The other sequence.
      * @returns {From<T>} A new From instance.
      */
-    public union(other: Iterable<T>): From<T> {
+    public concat(other: Iterable<T>): From<T> {
         const self = this;
         return From.fn<T>(function* () {
             yield* self;
@@ -716,7 +726,19 @@ export class From<T> implements Iterable<T> {
     }
 
     /**
-     * Correlates the elements of two sequences based on matching keys.
+     * The set union, as LINQ's Union: the elements of this sequence and then those of the other, each one once (the
+     * first time it appears), compared as distinct() does.
+     * @param {Iterable<T>} other - The other sequence.
+     * @param {EqualityComparer<T>} [equalityComparer] - Optional equality comparer; shallowEqual when not given.
+     * @returns {From<T>} A new From instance.
+     */
+    public union(other: Iterable<T>, equalityComparer?: EqualityComparer<T>): From<T> {
+        return this.concat(other).distinct(equalityComparer);
+    }
+
+    /**
+     * Correlates the elements of two sequences based on matching keys: one result per matching pair, so an element
+     * that matches several elements of the other sequence gives one result for each.
      * @template T2, R, R2
      * @param {Iterable<T2>} other - The other sequence.
      * @param {UnaryFunction<T, R>} thisKeySelector - Key selector for this sequence.
@@ -728,18 +750,20 @@ export class From<T> implements Iterable<T> {
 
         const self = this;
         return From.fn<R2>(() => {
-            const otherByKey = new Map<R, T2>();
-            for (let item of other) {
-                otherByKey.set(otherKeySelector(item), item);
+            const otherByKey = groupItemsByKey(other, otherKeySelector);
+            const results: R2[] = [];
+            for (const item of self) {
+                for (const otherItem of otherByKey.get(thisKeySelector(item)) ?? []) {
+                    results.push(resultSelector(item, otherItem));
+                }
             }
-            return Array.from(self)
-                        .filter(item => otherByKey.has(thisKeySelector(item)))
-                        .map(item => resultSelector(item, otherByKey.get(thisKeySelector(item))!));
+            return results;
         });
     }
 
     /**
-     * Performs a left join on two sequences.
+     * Performs a left join on two sequences: one result per matching pair, and one with `undefined` for each element of
+     * this sequence that matches none.
      * @template U, K, R
      * @param {Iterable<U>} other - The other sequence.
      * @param {UnaryFunction<T, K>} thisKeySelector - Key selector for this sequence.
@@ -751,11 +775,19 @@ export class From<T> implements Iterable<T> {
 
         const self = this;
         return From.fn<R>(() => {
-            const otherByKey = new Map<K, U>();
-            for (let item of other) {
-                otherByKey.set(otherKeySelector(item), item);
+            const otherByKey = groupItemsByKey(other, otherKeySelector);
+            const results: R[] = [];
+            for (const item of self) {
+                const matches = otherByKey.get(thisKeySelector(item));
+                if (matches === undefined) {
+                    results.push(resultSelector(item, undefined));
+                    continue;
+                }
+                for (const otherItem of matches) {
+                    results.push(resultSelector(item, otherItem));
+                }
             }
-            return Array.from(self).map(item => resultSelector(item, otherByKey.get(thisKeySelector(item))));
+            return results;
         });
     }
 
@@ -773,15 +805,8 @@ export class From<T> implements Iterable<T> {
 
         const self = this;
         return From.fn<R>(() => {
-            const otherByKeys = new Map<K, Array<U>>();
-            for (let item of other) {
-                const key = otherKeySelector(item);
-                if (!otherByKeys.has(key)) {
-                    otherByKeys.set(key, []);
-                }
-                otherByKeys.get(key)!.push(item);
-            }
-            return Array.from(self).map(item => resultSelector(item, otherByKeys.get(thisKeySelector(item)) || []));
+            const otherByKey = groupItemsByKey(other, otherKeySelector);
+            return Array.from(self).map(item => resultSelector(item, otherByKey.get(thisKeySelector(item)) ?? []));
         });
     }
 
@@ -798,21 +823,15 @@ export class From<T> implements Iterable<T> {
 
         const self = this;
         return From.fn<R>(() => {
-            const thisByKeys = new Map<K, Array<T>>();
-            for (let item of self) {
-                const key = thisKeySelector(item);
-                if (!thisByKeys.has(key)) {
-                    thisByKeys.set(key, []);
-                }
-                thisByKeys.get(key)!.push(item);
-            }
-            return Array.from(other).map(item => resultSelector(thisByKeys.get(otherKeySelector(item)) || [], item));
+            const thisByKey = groupItemsByKey(self, thisKeySelector);
+            return Array.from(other).map(item => resultSelector(thisByKey.get(otherKeySelector(item)) ?? [], item));
         });
     }
 
 
     /**
-     * Performs a right join on two sequences.
+     * Performs a right join on two sequences: one result per matching pair, and one with `undefined` for each element of
+     * the other sequence that matches none.
      * @template U, K, R
      * @param {Iterable<U>} other - The other sequence.
      * @param {UnaryFunction<T, K>} thisKeySelector - Key selector for this sequence.
@@ -824,16 +843,39 @@ export class From<T> implements Iterable<T> {
 
         const self = this;
         return From.fn<R>(() => {
-            const thisByKey = new Map<K, T>();
-            for (let item of self) {
-                thisByKey.set(thisKeySelector(item), item);
+            const thisByKey = groupItemsByKey(self, thisKeySelector);
+            const results: R[] = [];
+            for (const otherItem of other) {
+                const matches = thisByKey.get(otherKeySelector(otherItem));
+                if (matches === undefined) {
+                    results.push(resultSelector(undefined, otherItem));
+                    continue;
+                }
+                for (const item of matches) {
+                    results.push(resultSelector(item, otherItem));
+                }
             }
-            return Array.from(other).map(item => resultSelector(thisByKey.get(otherKeySelector(item)), item));
+            return results;
         });
     }
 
 }
 
+/** The items of a sequence in lists by their key, in their order, for the joins. */
+function groupItemsByKey<TItem, TKey>(items: Iterable<TItem>, keySelector: UnaryFunction<TItem, TKey>): Map<TKey, TItem[]> {
+    const itemsByKey = new Map<TKey, TItem[]>();
+    for (const item of items) {
+        const key = keySelector(item);
+        const group = itemsByKey.get(key);
+        if (group === undefined) {
+            itemsByKey.set(key, [item]);
+        } else {
+            group.push(item);
+        }
+    }
+    return itemsByKey;
+}
+
 /**
  * Represents a group of elements that have a common key.
  * @template TKey, T