@powfix/core-js 0.19.2 → 0.20.1

package/dist/browser/cjs/browser/utils/UUID.js

@@ -1,308 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UUID = void 0;
-const shared_1 = require("../../shared");
-/**
- * Represents a UUID (Universally Unique Identifier) and provides various utility
- * methods for validation, conversion, comparison and creation.
- */
-class UUID {
-    /* --------------------------------------------------------------------
-     * Validation helpers
-     * -------------------------------------------------------------------- */
-    /**
-     * Checks if the supplied value is a valid hex representation of a UUID.
-     * @param hex - The string to validate.
-     * @returns true if the string matches {@link REGEX_HEX}.
-     */
-    static isValidHex(hex) {
-        if (typeof hex !== 'string') {
-            return false;
-        }
-        return UUID.REGEX_HEX.test(hex);
-    }
-    /**
-     * Checks if the supplied value is a valid RFC 4122 UUID string.
-     * @param str - The string to validate.
-     * @returns true if the string matches {@link REGEX_RFC4122}.
-     */
-    static isValidString(str) {
-        if (typeof str !== 'string') {
-            return false;
-        }
-        return UUID.REGEX_RFC4122.test(str);
-    }
-    /**
-     * Checks whether an ArrayBufferView contains exactly {@link BYTE_LENGTH} bytes.
-     * @param bytes - The view to check.
-     * @returns true if the byte length is correct.
-     */
-    static isValidBytes(bytes) {
-        return bytes.byteLength === UUID.BYTE_LENGTH;
-    }
-    /**
-     * Generic validation that accepts either a string (hex or RFC 4122 format)
-     * or an ArrayBufferView containing the raw bytes.
-     * @param input - The value to validate.
-     * @returns true if the input is a valid representation of a UUID.
-     */
-    static isValid(input) {
-        if (typeof input === 'string') {
-            const length = input.length;
-            switch (length) {
-                case UUID.STR_LENGTH:
-                    // RFC 4122 uuid(string)
-                    // 9e472052-a654-4693-9a8b-3ce57ada3d6c
-                    return UUID.isValidString(input);
-                case UUID.HEX_STR_LENGTH:
-                    // RFC 4122 uuid(string) without hyphens
-                    // 9e472052a65446939a8b3ce57ada3d6c
-                    return UUID.isValidHex(input);
-                default:
-                    return false;
-            }
-        }
-        else if (ArrayBuffer.isView(input)) {
-            return UUID.isValidBytes(input);
-        }
-        else {
-            return false;
-        }
-    }
-    /* --------------------------------------------------------------------
-     * Parsing / formatting helpers
-     * -------------------------------------------------------------------- */
-    /**
-     * Inserts hyphens into a 32‑character hex string to produce an RFC 4122 string.
-     * @param hex - The plain hexadecimal UUID.
-     * @returns The formatted RFC 4122 string.
-     */
-    static formatHex(hex) {
-        if (hex.length !== UUID.HEX_STR_LENGTH) {
-            throw new Error(`hex length should be ${UUID.HEX_STR_LENGTH}`);
-        }
-        return hex.slice(0, 8) + '-' +
-            hex.slice(8, 12) + '-' +
-            hex.slice(12, 16) + '-' +
-            hex.slice(16, 20) + '-' +
-            hex.slice(20);
-    }
-    /** Removes all hyphens from a UUID string. */
-    static stripHyphens(str) {
-        return str.replace(/-/g, "");
-    }
-    /**
-     * Converts a plain hexadecimal UUID into a Uint8Array.
-     * @param hex - The hex string to parse.
-     * @returns A Uint8Array containing the raw bytes.
-     */
-    static parseHex(hex) {
-        if (hex.length !== UUID.HEX_STR_LENGTH) {
-            throw new Error(`Invalid hex string, length should be ${UUID.HEX_STR_LENGTH}`);
-        }
-        return shared_1.Uint8ArrayUtils.fromHex(hex);
-    }
-    /**
-     * Parses an RFC 4122 string into a Uint8Array.
-     * @param str - The formatted UUID string.
-     * @returns A Uint8Array containing the raw bytes.
-     */
-    static parseString(str) {
-        if (str.length !== UUID.STR_LENGTH) {
-            throw new Error(`Invalid UUID string, invalid character length should be ${UUID.STR_LENGTH}`);
-        }
-        if (!UUID.isValid(str)) {
-            throw new Error('Invalid UUID string, should be RFC 4122 format');
-        }
-        const hex = UUID.stripHyphens(str);
-        if (hex.length !== UUID.HEX_STR_LENGTH) {
-            throw new Error('Invalid UUID string, invalid character length after strip hyphens');
-        }
-        return shared_1.Uint8ArrayUtils.fromHex(hex);
-    }
-    /**
-     * Parses an ArrayBufferView into a Uint8Array ensuring the correct byte length.
-     * @param bytes - The view to parse.
-     * @returns A Uint8Array containing the raw bytes.
-     */
-    static parseBytes(bytes) {
-        const view = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        if (view.length !== UUID.BYTE_LENGTH) {
-            throw new Error(`Expected ${UUID.BYTE_LENGTH} bytes`);
-        }
-        return new Uint8Array(view);
-    }
-    /* --------------------------------------------------------------------
-     * Factory methods
-     * -------------------------------------------------------------------- */
-    /**
-     * Creates a UUID instance from a plain hexadecimal string.
-     * @param hex - The hex representation of the UUID.
-     * @returns A new {@link UUID} object.
-     */
-    static fromHex(hex) {
-        return new UUID(UUID.parseHex(hex));
-    }
-    /**
-     * Creates a UUID instance from an RFC 4122 formatted string.
-     * @param str - The UUID string with hyphens.
-     * @returns A new {@link UUID} object.
-     */
-    static fromString(str) {
-        return new UUID(UUID.parseString(str));
-    }
-    /**
-     * Creates a UUID instance from raw bytes.
-     * @param bytes - An ArrayBufferView containing 16 bytes.
-     * @returns A new {@link UUID} object.
-     */
-    static fromBytes(bytes) {
-        return new UUID(UUID.parseBytes(bytes));
-    }
-    /**
-     * Parses any supported input (string or bytes) and returns the raw byte array.
-     * @param input - The value to parse.
-     * @returns A Uint8Array of length {@link BYTE_LENGTH}.
-     */
-    static parse(input) {
-        if (typeof input === 'string') {
-            const length = input.length;
-            switch (length) {
-                case UUID.STR_LENGTH:
-                    // RFC 4122 uuid(string)
-                    return UUID.parseString(input);
-                case UUID.HEX_STR_LENGTH:
-                    // RFC 4122 uuid(string) without hyphens
-                    return UUID.parseHex(input);
-                default:
-                    throw new Error(`Invalid input string, length should be ${UUID.STR_LENGTH} or ${UUID.HEX_STR_LENGTH}`);
-            }
-        }
-        else if (ArrayBuffer.isView(input)) {
-            return UUID.parseBytes(input);
-        }
-        else {
-            throw new Error("Invalid input, Expected string or ArrayBufferView");
-        }
-    }
-    /**
-     * Creates a UUID from any supported input type.
-     * @param input - The value to parse.
-     * @returns A new {@link UUID} object.
-     */
-    static from(input) {
-        return UUID.fromBytes(UUID.parse(input));
-    }
-    /** Returns the nil (all zero) UUID. */
-    static nil() {
-        return UUID.fromBytes(new Uint8Array(UUID.BYTE_LENGTH));
-    }
-    /** Returns a UUID consisting of all 0xFF bytes. */
-    static max() {
-        return UUID.fromBytes((new Uint8Array(UUID.BYTE_LENGTH)).fill(0xFF));
-    }
-    /* --------------------------------------------------------------------
-     * Equality / comparison
-     * -------------------------------------------------------------------- */
-    /**
-     * Compares multiple UUIDs for strict equality.
-     * @param uuids - The UUIDs to compare (at least two required).
-     * @returns true if all provided UUIDs are identical.
-     */
-    static equals(...uuids) {
-        const n = uuids.length;
-        if (n < 2) {
-            throw new Error('At least two UUIDs required for comparison');
-        }
-        const ref = uuids[0].bytes;
-        for (let i = 1; i < n; ++i) {
-            const b = uuids[i].bytes;
-            for (let j = 0; j < UUID.BYTE_LENGTH; ++j) {
-                if (ref[j] !== b[j])
-                    return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Lexicographically compares two UUIDs.
-     * @param uuid1 - The first UUID.
-     * @param uuid2 - The second UUID.
-     * @returns -1 if uuid1 < uuid2, 1 if uuid1 > uuid2, 0 otherwise.
-     */
-    static compare(uuid1, uuid2) {
-        const a = uuid1.bytes;
-        const b = uuid2.bytes;
-        for (let i = 0; i < UUID.BYTE_LENGTH; i++) {
-            if (a[i] !== b[i])
-                return a[i] < b[i] ? -1 : 1;
-        }
-        return 0;
-    }
-    /**
-     * Constructs a new {@link UUID} instance from any supported input type.
-     * @param input - The value to parse (string or ArrayBufferView).
-     */
-    constructor(input) {
-        this.bytes = UUID.parse(input);
-    }
-    /** Instance wrapper for {@link equals}. */
-    equals(...uuids) {
-        return UUID.equals(this, ...uuids);
-    }
-    /** Instance wrapper for {@link compare}. */
-    compare(other) {
-        return UUID.compare(this, other);
-    }
-    /**
-     * Returns the RFC 4122 string representation of this UUID.
-     * @returns The formatted UUID string.
-     */
-    toString() {
-        if (this._str != null) {
-            return this._str;
-        }
-        const hex = this.toHex();
-        this._str = UUID.formatHex(hex);
-        return this._str;
-    }
-    /**
-     * Returns the plain hexadecimal representation of this UUID.
-     * @returns A 32‑character hex string.
-     */
-    toHex() {
-        if (this._hex != null) {
-            return this._hex;
-        }
-        this._hex = shared_1.Uint8ArrayUtils.toHex(this.bytes);
-        return this._hex;
-    }
-    /**
-     * Returns a copy of the raw byte array.
-     * @returns A new Uint8Array containing the UUID bytes.
-     */
-    toBytes() {
-        return new Uint8Array(this.bytes);
-    }
-    /** JSON serialization helper – returns the RFC 4122 string. */
-    toJSON() {
-        return this.toString();
-    }
+const UUID_1 = require("../../shared/utils/UUID");
+class UUID extends UUID_1.UUID {
 }
 exports.UUID = UUID;
-/* --------------------------------------------------------------------
- * Regular expressions used to validate UUIDs in different string forms
- * -------------------------------------------------------------------- */
-/** Matches a 32‑character hexadecimal representation of a UUID without hyphens. */
-UUID.REGEX_HEX = /^[0-9a-fA-F]{8}[0-9a-fA-F]{4}[1-5][0-9a-fA-F]{3}[89abAB][0-9a-fA-F]{3}[0-9a-fA-F]{12}$/;
-/** Matches the RFC 4122 canonical UUID format with hyphens. */
-UUID.REGEX_RFC4122 = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
-/* --------------------------------------------------------------------
- * Constant lengths used throughout the class
- * -------------------------------------------------------------------- */
-/** Number of bytes that represent a UUID. */
-UUID.BYTE_LENGTH = 16;
-/** Total length of an RFC 4122 UUID string (including hyphens). */
-UUID.STR_LENGTH = 36;
-/** Length of a UUID represented as a plain hexadecimal string. */
-UUID.HEX_STR_LENGTH = 32;

package/dist/{node/cjs/browser → browser/cjs/shared}/utils/UUID.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UUID = void 0;
-const shared_1 = require("../../shared");
+const index_1 = require("../index");
 /**
  * Represents a UUID (Universally Unique Identifier) and provides various utility
  * methods for validation, conversion, comparison and creation.
@@ -62,6 +62,9 @@ class UUID {
                     return false;
             }
         }
+        else if (input instanceof UUID) {
+            return UUID.isValidBytes(input.bytes);
+        }
         else if (ArrayBuffer.isView(input)) {
             return UUID.isValidBytes(input);
         }
@@ -100,7 +103,7 @@ class UUID {
         if (hex.length !== UUID.HEX_STR_LENGTH) {
             throw new Error(`Invalid hex string, length should be ${UUID.HEX_STR_LENGTH}`);
         }
-        return shared_1.Uint8ArrayUtils.fromHex(hex);
+        return index_1.Uint8ArrayUtils.fromHex(hex);
     }
     /**
      * Parses an RFC 4122 string into a Uint8Array.
@@ -118,7 +121,7 @@ class UUID {
         if (hex.length !== UUID.HEX_STR_LENGTH) {
             throw new Error('Invalid UUID string, invalid character length after strip hyphens');
         }
-        return shared_1.Uint8ArrayUtils.fromHex(hex);
+        return index_1.Uint8ArrayUtils.fromHex(hex);
     }
     /**
      * Parses an ArrayBufferView into a Uint8Array ensuring the correct byte length.
@@ -141,7 +144,7 @@ class UUID {
      * @returns A new {@link UUID} object.
      */
     static fromHex(hex) {
-        return new UUID(UUID.parseHex(hex));
+        return new this(UUID.parseHex(hex));
     }
     /**
      * Creates a UUID instance from an RFC 4122 formatted string.
@@ -149,7 +152,7 @@ class UUID {
      * @returns A new {@link UUID} object.
      */
     static fromString(str) {
-        return new UUID(UUID.parseString(str));
+        return new this(UUID.parseString(str));
     }
     /**
      * Creates a UUID instance from raw bytes.
@@ -157,7 +160,7 @@ class UUID {
      * @returns A new {@link UUID} object.
      */
     static fromBytes(bytes) {
-        return new UUID(UUID.parseBytes(bytes));
+        return new this(UUID.parseBytes(bytes));
     }
     /**
      * Parses any supported input (string or bytes) and returns the raw byte array.
@@ -178,6 +181,9 @@ class UUID {
                     throw new Error(`Invalid input string, length should be ${UUID.STR_LENGTH} or ${UUID.HEX_STR_LENGTH}`);
             }
         }
+        else if (input instanceof UUID) {
+            return input.toBytes();
+        }
         else if (ArrayBuffer.isView(input)) {
             return UUID.parseBytes(input);
         }
@@ -191,15 +197,15 @@ class UUID {
      * @returns A new {@link UUID} object.
      */
     static from(input) {
-        return UUID.fromBytes(UUID.parse(input));
+        return this.fromBytes(UUID.parse(input));
     }
     /** Returns the nil (all zero) UUID. */
     static nil() {
-        return UUID.fromBytes(new Uint8Array(UUID.BYTE_LENGTH));
+        return this.fromBytes(new Uint8Array(UUID.BYTE_LENGTH));
     }
     /** Returns a UUID consisting of all 0xFF bytes. */
     static max() {
-        return UUID.fromBytes((new Uint8Array(UUID.BYTE_LENGTH)).fill(0xFF));
+        return this.fromBytes((new Uint8Array(UUID.BYTE_LENGTH)).fill(0xFF));
     }
     /* --------------------------------------------------------------------
      * Equality / comparison
@@ -274,7 +280,7 @@ class UUID {
         if (this._hex != null) {
             return this._hex;
         }
-        this._hex = shared_1.Uint8ArrayUtils.toHex(this.bytes);
+        this._hex = index_1.Uint8ArrayUtils.toHex(this.bytes);
         return this._hex;
     }
     /**

package/dist/browser/cjs/shared/utils/UUID.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/browser/cjs/shared/utils/global/{fallbackIfEqual.js → fallbackIfMatch.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fallbackIfEqual = fallbackIfEqual;
-function fallbackIfEqual(value, condition, fallback) {
+exports.fallbackIfMatch = fallbackIfMatch;
+function fallbackIfMatch(value, condition, fallback) {
     if (typeof value === typeof condition && value === condition) {
         return fallback;
     }

package/dist/browser/cjs/shared/utils/global/fallbackIfNull.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fallbackIfNull = fallbackIfNull;
-const fallbackIfEqual_1 = require("./fallbackIfEqual");
+const fallbackIfMatch_1 = require("./fallbackIfMatch");
 function fallbackIfNull(value, fallback) {
-    return (0, fallbackIfEqual_1.fallbackIfEqual)(value, null, fallback);
+    return (0, fallbackIfMatch_1.fallbackIfMatch)(value, null, fallback);
 }

package/dist/browser/cjs/shared/utils/global/fallbackIfNullish.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fallbackIfNullish = fallbackIfNullish;
+function fallbackIfNullish(value, fallback) {
+    if (value == null) {
+        return fallback;
+    }
+    return value;
+}

package/dist/browser/cjs/shared/utils/global/fallbackIfUndefined.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fallbackIfUndefined = fallbackIfUndefined;
-const fallbackIfEqual_1 = require("./fallbackIfEqual");
+const fallbackIfMatch_1 = require("./fallbackIfMatch");
 function fallbackIfUndefined(value, fallback) {
-    return (0, fallbackIfEqual_1.fallbackIfEqual)(value, undefined, fallback);
+    return (0, fallbackIfMatch_1.fallbackIfMatch)(value, undefined, fallback);
 }

package/dist/browser/cjs/shared/utils/global/index.js

@@ -21,8 +21,9 @@ __exportStar(require("./btoa"), exports);
 __exportStar(require("./castArray"), exports);
 __exportStar(require("./circularDistance"), exports);
 __exportStar(require("./sleep"), exports);
-__exportStar(require("./fallbackIfEqual"), exports);
+__exportStar(require("./fallbackIfMatch"), exports);
 __exportStar(require("./fallbackIfNull"), exports);
+__exportStar(require("./fallbackIfNullish"), exports);
 __exportStar(require("./fallbackIfUndefined"), exports);
 __exportStar(require("./firstNonNullish"), exports);
 __exportStar(require("./flat"), exports);

package/dist/browser/cjs/shared/utils/index.js

@@ -19,6 +19,8 @@ __exportStar(require("./ArrayUtils"), exports);
 __exportStar(require("./AxiosUtils"), exports);
 __exportStar(require("./StringUtils"), exports);
 __exportStar(require("./Uint8ArrayUtils"), exports);
+// export * from './UUID';
+__exportStar(require("./UUID.types"), exports);
 __exportStar(require("./UuidUtils"), exports);
 __exportStar(require("./BooleanUtils"), exports);
 __exportStar(require("./Calc"), exports);