lifecycleion 0.0.1

package/dist/lib/id-helpers.d.ts

@@ -0,0 +1,198 @@
+/**
+ * Supported identifier types:
+ *
+ * - **`objectID`**: MongoDB-style ObjectID
+ *   - Format: 24 hexadecimal characters
+ *   - Timestamp-based: Yes (sortable by creation time)
+ *   - Case-sensitive: No (accepts both uppercase and lowercase)
+ *   - Example: `"507f1f77bcf86cd799439011"`
+ *
+ * - **`uuid4`**: UUID version 4
+ *   - Format: 36 characters (32 hex + 4 dashes): `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`
+ *   - Timestamp-based: No (random)
+ *   - Case-sensitive: No (accepts both uppercase and lowercase)
+ *   - Example: `"9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d"`
+ *
+ * - **`uuid7`**: UUID version 7
+ *   - Format: 36 characters (32 hex + 4 dashes): `xxxxxxxx-xxxx-7xxx-yxxx-xxxxxxxxxxxx`
+ *   - Timestamp-based: Yes (sortable by creation time)
+ *   - Case-sensitive: No (accepts both uppercase and lowercase)
+ *   - Example: `"018e8c6e-4f7e-7000-8000-0123456789ab"`
+ *
+ * - **`ulid`**: Universally Unique Lexicographically Sortable Identifier
+ *   - Format: 26 characters using Crockford's base32 alphabet
+ *   - Timestamp-based: Yes (sortable by creation time)
+ *   - Case-sensitive: No (canonical form is uppercase, but accepts lowercase)
+ *   - Example: `"01ARZ3NDEKTSV4RRFFQ69G5FAV"`
+ */
+type IdentifierType = 'objectID' | 'uuid4' | 'uuid7' | 'ulid';
+/**
+ * Array of all supported identifier types.
+ */
+declare const IDENTIFIER_TYPES: readonly ["objectID", "uuid4", "uuid7", "ulid"];
+/**
+ * Generates a unique identifier of the specified type.
+ *
+ * @param type - The type of identifier to generate:
+ *   - `objectID`: MongoDB ObjectID (24 hex chars, timestamp-based)
+ *   - `uuid4`: UUID v4 (random, not sortable)
+ *   - `uuid7`: UUID v7 (timestamp-based, sortable)
+ *   - `ulid`: ULID (timestamp-based, sortable, case-insensitive)
+ * @param seedTime - Optional timestamp in milliseconds to seed the ID with.
+ *   - Supported by: `objectID`, `uuid7`, `ulid`
+ *   - Ignored by: `uuid4` (always random)
+ *   - Use this for testing or when you need IDs to have a specific timestamp
+ * @returns A unique identifier string
+ * @throws {TypeError} If an invalid type is provided
+ * @throws {TypeError} If `seedTime` is provided but is not a non-negative finite number
+ *
+ * @example
+ * ```typescript
+ * // Generate random IDs
+ * const objId = generateID('objectID');  // "507f1f77bcf86cd799439011"
+ * const uuid4 = generateID('uuid4');     // "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d"
+ * const uuid7 = generateID('uuid7');     // "018e8c6e-4f7e-7000-8000-0123456789ab"
+ * const ulid = generateID('ulid');       // "01ARZ3NDEKTSV4RRFFQ69G5FAV"
+ *
+ * // Generate IDs with a specific timestamp
+ * const timestamp = Date.now();
+ * const seededId = generateID('uuid7', timestamp);
+ * ```
+ */
+declare function generateID(type: IdentifierType, seedTime?: number): string;
+/**
+ * Validates that a string is a valid identifier of the specified type.
+ *
+ * Performs strict validation:
+ * - `objectID`: Must be 24 hexadecimal characters
+ * - `uuid4`: Must be a valid UUID with version 4
+ * - `uuid7`: Must be a valid UUID with version 7
+ * - `ulid`: Must be 26 characters from the ULID character set
+ *
+ * Empty IDs (from `emptyID()`) are considered valid.
+ * Non-string `id` values return `false`.
+ *
+ * @param type - The expected identifier type
+ * @param id - The identifier string to validate
+ * @returns `true` if the ID is valid for the specified type, `false` otherwise
+ * @throws {TypeError} If an invalid type is provided
+ *
+ * @example
+ * ```typescript
+ * validateID('uuid4', '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d');  // true
+ * validateID('uuid4', '018e8c6e-4f7e-7000-8000-0123456789ab');  // false (this is uuid7)
+ * validateID('objectID', '507f1f77bcf86cd799439011');           // true
+ * validateID('objectID', 'invalid');                            // false
+ * ```
+ */
+declare function validateID(type: IdentifierType, id: string): boolean;
+/**
+ * Returns an empty/null identifier for the specified type.
+ *
+ * Empty IDs are valid IDs (pass `validateID()`) but represent a null/empty state.
+ * Useful as default values or placeholders in databases.
+ *
+ * Empty ID formats:
+ * - `objectID`: `"000000000000000000000000"` (24 zeros)
+ * - `uuid4`: `"00000000-0000-0000-0000-000000000000"` (nil UUID)
+ * - `uuid7`: `"00000000-0000-0000-0000-000000000000"` (nil UUID)
+ * - `ulid`: `"00000000000000000000000000"` (26 zeros)
+ *
+ * @param type - The type of empty identifier to generate
+ * @returns An empty identifier string
+ * @throws {TypeError} If an invalid type is provided
+ *
+ * @example
+ * ```typescript
+ * const emptyUuid = emptyID('uuid4');  // "00000000-0000-0000-0000-000000000000"
+ * validateID('uuid4', emptyUuid);      // true
+ * isEmptyID('uuid4', emptyUuid);       // true
+ * ```
+ */
+declare function emptyID(type: IdentifierType): string;
+/**
+ * Checks if an identifier is an empty/null ID.
+ *
+ * Compares the provided ID against the empty ID for the specified type.
+ * This is useful for checking if an ID represents a null/empty state.
+ *
+ * @param type - The identifier type to check against
+ * @param id - The identifier string to check
+ * @returns `true` if the ID is empty for the specified type, `false` otherwise.
+ * Non-string `id` values return `false`.
+ * @throws {TypeError} If an invalid type is provided
+ *
+ * @example
+ * ```typescript
+ * const emptyUuid = emptyID('uuid4');
+ * const realUuid = generateID('uuid4');
+ *
+ * isEmptyID('uuid4', emptyUuid);  // true
+ * isEmptyID('uuid4', realUuid);   // false
+ * ```
+ */
+declare function isEmptyID(type: IdentifierType, id: string): boolean;
+/**
+ * Helper class for working with identifiers of a specific type.
+ *
+ * This class provides a convenient way to work with IDs without repeatedly
+ * specifying the type parameter. Initialize it with your preferred ID type,
+ * then use its methods without passing the type each time.
+ *
+ * @example
+ * ```typescript
+ * // Create a helper for UUID v7 identifiers
+ * const idHelper = new IDHelpers('uuid7');
+ *
+ * // Generate IDs without specifying type each time
+ * const id1 = idHelper.generateID();
+ * const id2 = idHelper.generateID(Date.now());
+ *
+ * // Validate IDs
+ * if (idHelper.validateID(someId)) {
+ *   console.log('Valid uuid7');
+ * }
+ *
+ * // Check for empty IDs
+ * const empty = idHelper.emptyID();
+ * console.log(idHelper.isEmptyID(empty));  // true
+ * ```
+ */
+declare class IDHelpers {
+    private _type;
+    /**
+     * Gets the identifier type this helper is configured for.
+     */
+    get type(): IdentifierType;
+    /**
+     * Creates a new ID helper for the specified type.
+     * @param type - The identifier type to use for all operations
+     * @throws {TypeError} If an invalid type is provided
+     */
+    constructor(type: IdentifierType);
+    /**
+     * Generates a new identifier using the configured type.
+     * @param seedTime - Optional timestamp in milliseconds to seed the ID with
+     * @returns A unique identifier string
+     */
+    generateID(seedTime?: number): string;
+    /**
+     * Validates an identifier against the configured type.
+     * @param id - The identifier string to validate
+     * @returns `true` if valid, `false` otherwise
+     */
+    validateID(id: string): boolean;
+    /**
+     * Returns an empty identifier for the configured type.
+     * @returns An empty identifier string
+     */
+    emptyID(): string;
+    /**
+     * Checks if an identifier is empty for the configured type.
+     * @param id - The identifier string to check
+     * @returns `true` if empty, `false` otherwise
+     */
+    isEmptyID(id: string): boolean;
+}
+
+export { IDENTIFIER_TYPES, IDHelpers, type IdentifierType, emptyID, generateID, isEmptyID, validateID };

package/dist/lib/id-helpers.js

@@ -0,0 +1,170 @@
+// src/lib/id-helpers.ts
+import ObjectID from "bson-objectid";
+import {
+  v4 as UUIDv4,
+  v7 as UUIDv7,
+  validate as uuidValidate,
+  version as uuidVersion
+} from "uuid";
+import { ulid } from "ulid";
+
+// src/lib/unix-time-helpers.ts
+function convertMSToUnix(value) {
+  return Math.floor(value / 1e3);
+}
+
+// src/lib/id-helpers.ts
+var IDENTIFIER_TYPES = ["objectID", "uuid4", "uuid7", "ulid"];
+function assertIdentifierType(type) {
+  if (!IDENTIFIER_TYPES.includes(type)) {
+    throw new TypeError(
+      `Invalid ID type given: "${type}". Expected one of: ${IDENTIFIER_TYPES.join(", ")}`
+    );
+  }
+}
+function generateID(type, seedTime) {
+  assertIdentifierType(type);
+  if (seedTime !== void 0 && (!Number.isFinite(seedTime) || seedTime < 0)) {
+    throw new TypeError(
+      `seedTime must be a non-negative finite number (milliseconds), got: ${seedTime}`
+    );
+  }
+  if (type === "objectID") {
+    if (seedTime !== void 0) {
+      const unixTime = convertMSToUnix(seedTime);
+      return new ObjectID(unixTime).toHexString();
+    } else {
+      return new ObjectID().toHexString();
+    }
+  } else if (type === "uuid4") {
+    return UUIDv4();
+  } else if (type === "uuid7") {
+    if (seedTime !== void 0) {
+      return UUIDv7({ msecs: seedTime });
+    } else {
+      return UUIDv7();
+    }
+  } else if (type === "ulid") {
+    if (seedTime !== void 0) {
+      return ulid(seedTime);
+    } else {
+      return ulid();
+    }
+  } else {
+    throw new TypeError(`Unhandled identifier type: "${type}"`);
+  }
+}
+function validateID(type, id) {
+  assertIdentifierType(type);
+  if (typeof id !== "string") {
+    return false;
+  }
+  if (type === "objectID") {
+    if (id.match(/^[0-9a-fA-F]{24}$/)) {
+      return true;
+    } else {
+      return false;
+    }
+  } else if (type === "uuid4" || type === "uuid7") {
+    if (isEmptyID(type, id)) {
+      return true;
+    }
+    const isValid = uuidValidate(id);
+    if (!isValid) {
+      return false;
+    }
+    const version = uuidVersion(id);
+    if (type === "uuid4" && version === 4) {
+      return true;
+    } else if (type === "uuid7" && version === 7) {
+      return true;
+    } else {
+      return false;
+    }
+  } else if (type === "ulid") {
+    if (id.match(/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i)) {
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    throw new TypeError(`Unhandled identifier type: "${type}"`);
+  }
+}
+function emptyID(type) {
+  assertIdentifierType(type);
+  if (type === "objectID") {
+    return "0".repeat(24);
+  } else if (type === "uuid4" || type === "uuid7") {
+    return "00000000-0000-0000-0000-000000000000";
+  } else if (type === "ulid") {
+    return "0".repeat(26);
+  } else {
+    throw new TypeError(`Unhandled identifier type: "${type}"`);
+  }
+}
+function isEmptyID(type, id) {
+  assertIdentifierType(type);
+  if (typeof id !== "string") {
+    return false;
+  }
+  return emptyID(type) === id;
+}
+var IDHelpers = class {
+  _type;
+  /**
+   * Gets the identifier type this helper is configured for.
+   */
+  get type() {
+    return this._type;
+  }
+  /**
+   * Creates a new ID helper for the specified type.
+   * @param type - The identifier type to use for all operations
+   * @throws {TypeError} If an invalid type is provided
+   */
+  constructor(type) {
+    assertIdentifierType(type);
+    this._type = type;
+  }
+  /**
+   * Generates a new identifier using the configured type.
+   * @param seedTime - Optional timestamp in milliseconds to seed the ID with
+   * @returns A unique identifier string
+   */
+  generateID(seedTime) {
+    return generateID(this._type, seedTime);
+  }
+  /**
+   * Validates an identifier against the configured type.
+   * @param id - The identifier string to validate
+   * @returns `true` if valid, `false` otherwise
+   */
+  validateID(id) {
+    return validateID(this._type, id);
+  }
+  /**
+   * Returns an empty identifier for the configured type.
+   * @returns An empty identifier string
+   */
+  emptyID() {
+    return emptyID(this._type);
+  }
+  /**
+   * Checks if an identifier is empty for the configured type.
+   * @param id - The identifier string to check
+   * @returns `true` if empty, `false` otherwise
+   */
+  isEmptyID(id) {
+    return isEmptyID(this._type, id);
+  }
+};
+export {
+  IDENTIFIER_TYPES,
+  IDHelpers,
+  emptyID,
+  generateID,
+  isEmptyID,
+  validateID
+};
+//# sourceMappingURL=id-helpers.js.map

package/dist/lib/id-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/id-helpers.ts","../../src/lib/unix-time-helpers.ts"],"sourcesContent":["import ObjectID from 'bson-objectid';\nimport {\n  v4 as UUIDv4,\n  v7 as UUIDv7,\n  validate as uuidValidate,\n  version as uuidVersion,\n} from 'uuid';\nimport { ulid } from 'ulid';\nimport { convertMSToUnix } from './unix-time-helpers';\n\n/**\n * Supported identifier types:\n *\n * - **`objectID`**: MongoDB-style ObjectID\n *   - Format: 24 hexadecimal characters\n *   - Timestamp-based: Yes (sortable by creation time)\n *   - Case-sensitive: No (accepts both uppercase and lowercase)\n *   - Example: `\"507f1f77bcf86cd799439011\"`\n *\n * - **`uuid4`**: UUID version 4\n *   - Format: 36 characters (32 hex + 4 dashes): `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`\n *   - Timestamp-based: No (random)\n *   - Case-sensitive: No (accepts both uppercase and lowercase)\n *   - Example: `\"9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d\"`\n *\n * - **`uuid7`**: UUID version 7\n *   - Format: 36 characters (32 hex + 4 dashes): `xxxxxxxx-xxxx-7xxx-yxxx-xxxxxxxxxxxx`\n *   - Timestamp-based: Yes (sortable by creation time)\n *   - Case-sensitive: No (accepts both uppercase and lowercase)\n *   - Example: `\"018e8c6e-4f7e-7000-8000-0123456789ab\"`\n *\n * - **`ulid`**: Universally Unique Lexicographically Sortable Identifier\n *   - Format: 26 characters using Crockford's base32 alphabet\n *   - Timestamp-based: Yes (sortable by creation time)\n *   - Case-sensitive: No (canonical form is uppercase, but accepts lowercase)\n *   - Example: `\"01ARZ3NDEKTSV4RRFFQ69G5FAV\"`\n */\nexport type IdentifierType = 'objectID' | 'uuid4' | 'uuid7' | 'ulid';\n\n/**\n * Array of all supported identifier types.\n */\nexport const IDENTIFIER_TYPES = ['objectID', 'uuid4', 'uuid7', 'ulid'] as const;\n\nfunction assertIdentifierType(type: unknown): asserts type is IdentifierType {\n  if (!IDENTIFIER_TYPES.includes(type as IdentifierType)) {\n    throw new TypeError(\n      `Invalid ID type given: \"${type as string}\". Expected one of: ${IDENTIFIER_TYPES.join(', ')}`,\n    );\n  }\n}\n\n/**\n * Generates a unique identifier of the specified type.\n *\n * @param type - The type of identifier to generate:\n *   - `objectID`: MongoDB ObjectID (24 hex chars, timestamp-based)\n *   - `uuid4`: UUID v4 (random, not sortable)\n *   - `uuid7`: UUID v7 (timestamp-based, sortable)\n *   - `ulid`: ULID (timestamp-based, sortable, case-insensitive)\n * @param seedTime - Optional timestamp in milliseconds to seed the ID with.\n *   - Supported by: `objectID`, `uuid7`, `ulid`\n *   - Ignored by: `uuid4` (always random)\n *   - Use this for testing or when you need IDs to have a specific timestamp\n * @returns A unique identifier string\n * @throws {TypeError} If an invalid type is provided\n * @throws {TypeError} If `seedTime` is provided but is not a non-negative finite number\n *\n * @example\n * ```typescript\n * // Generate random IDs\n * const objId = generateID('objectID');  // \"507f1f77bcf86cd799439011\"\n * const uuid4 = generateID('uuid4');     // \"9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d\"\n * const uuid7 = generateID('uuid7');     // \"018e8c6e-4f7e-7000-8000-0123456789ab\"\n * const ulid = generateID('ulid');       // \"01ARZ3NDEKTSV4RRFFQ69G5FAV\"\n *\n * // Generate IDs with a specific timestamp\n * const timestamp = Date.now();\n * const seededId = generateID('uuid7', timestamp);\n * ```\n */\nexport function generateID(type: IdentifierType, seedTime?: number): string {\n  assertIdentifierType(type);\n\n  if (seedTime !== undefined && (!Number.isFinite(seedTime) || seedTime < 0)) {\n    throw new TypeError(\n      `seedTime must be a non-negative finite number (milliseconds), got: ${seedTime}`,\n    );\n  }\n\n  if (type === 'objectID') {\n    if (seedTime !== undefined) {\n      // expects as unix time\n      const unixTime = convertMSToUnix(seedTime);\n\n      return new ObjectID(unixTime).toHexString();\n    } else {\n      return new ObjectID().toHexString();\n    }\n  } else if (type === 'uuid4') {\n    return UUIDv4();\n  } else if (type === 'uuid7') {\n    if (seedTime !== undefined) {\n      // expect in milliseconds\n      return UUIDv7({ msecs: seedTime });\n    } else {\n      return UUIDv7();\n    }\n  } else if (type === 'ulid') {\n    if (seedTime !== undefined) {\n      // expect in milliseconds\n      return ulid(seedTime);\n    } else {\n      return ulid();\n    }\n  } else {\n    throw new TypeError(`Unhandled identifier type: \"${type as string}\"`);\n  }\n}\n\n/**\n * Validates that a string is a valid identifier of the specified type.\n *\n * Performs strict validation:\n * - `objectID`: Must be 24 hexadecimal characters\n * - `uuid4`: Must be a valid UUID with version 4\n * - `uuid7`: Must be a valid UUID with version 7\n * - `ulid`: Must be 26 characters from the ULID character set\n *\n * Empty IDs (from `emptyID()`) are considered valid.\n * Non-string `id` values return `false`.\n *\n * @param type - The expected identifier type\n * @param id - The identifier string to validate\n * @returns `true` if the ID is valid for the specified type, `false` otherwise\n * @throws {TypeError} If an invalid type is provided\n *\n * @example\n * ```typescript\n * validateID('uuid4', '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d');  // true\n * validateID('uuid4', '018e8c6e-4f7e-7000-8000-0123456789ab');  // false (this is uuid7)\n * validateID('objectID', '507f1f77bcf86cd799439011');           // true\n * validateID('objectID', 'invalid');                            // false\n * ```\n */\nexport function validateID(type: IdentifierType, id: string): boolean {\n  assertIdentifierType(type);\n\n  if (typeof id !== 'string') {\n    return false;\n  }\n\n  if (type === 'objectID') {\n    if (id.match(/^[0-9a-fA-F]{24}$/)) {\n      return true;\n    } else {\n      return false;\n    }\n  } else if (type === 'uuid4' || type === 'uuid7') {\n    // Check if it's the empty ID first\n    if (isEmptyID(type, id)) {\n      return true;\n    }\n\n    const isValid = uuidValidate(id);\n    if (!isValid) {\n      return false;\n    }\n\n    // Check the specific UUID version\n    const version = uuidVersion(id);\n    if (type === 'uuid4' && version === 4) {\n      return true;\n    } else if (type === 'uuid7' && version === 7) {\n      return true;\n    } else {\n      return false;\n    }\n  } else if (type === 'ulid') {\n    if (id.match(/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i)) {\n      return true;\n    } else {\n      return false;\n    }\n  } else {\n    throw new TypeError(`Unhandled identifier type: \"${type as string}\"`);\n  }\n}\n\n/**\n * Returns an empty/null identifier for the specified type.\n *\n * Empty IDs are valid IDs (pass `validateID()`) but represent a null/empty state.\n * Useful as default values or placeholders in databases.\n *\n * Empty ID formats:\n * - `objectID`: `\"000000000000000000000000\"` (24 zeros)\n * - `uuid4`: `\"00000000-0000-0000-0000-000000000000\"` (nil UUID)\n * - `uuid7`: `\"00000000-0000-0000-0000-000000000000\"` (nil UUID)\n * - `ulid`: `\"00000000000000000000000000\"` (26 zeros)\n *\n * @param type - The type of empty identifier to generate\n * @returns An empty identifier string\n * @throws {TypeError} If an invalid type is provided\n *\n * @example\n * ```typescript\n * const emptyUuid = emptyID('uuid4');  // \"00000000-0000-0000-0000-000000000000\"\n * validateID('uuid4', emptyUuid);      // true\n * isEmptyID('uuid4', emptyUuid);       // true\n * ```\n */\nexport function emptyID(type: IdentifierType): string {\n  assertIdentifierType(type);\n\n  if (type === 'objectID') {\n    return '0'.repeat(24);\n  } else if (type === 'uuid4' || type === 'uuid7') {\n    return '00000000-0000-0000-0000-000000000000';\n  } else if (type === 'ulid') {\n    return '0'.repeat(26);\n  } else {\n    throw new TypeError(`Unhandled identifier type: \"${type as string}\"`);\n  }\n}\n\n/**\n * Checks if an identifier is an empty/null ID.\n *\n * Compares the provided ID against the empty ID for the specified type.\n * This is useful for checking if an ID represents a null/empty state.\n *\n * @param type - The identifier type to check against\n * @param id - The identifier string to check\n * @returns `true` if the ID is empty for the specified type, `false` otherwise.\n * Non-string `id` values return `false`.\n * @throws {TypeError} If an invalid type is provided\n *\n * @example\n * ```typescript\n * const emptyUuid = emptyID('uuid4');\n * const realUuid = generateID('uuid4');\n *\n * isEmptyID('uuid4', emptyUuid);  // true\n * isEmptyID('uuid4', realUuid);   // false\n * ```\n */\nexport function isEmptyID(type: IdentifierType, id: string): boolean {\n  assertIdentifierType(type);\n\n  if (typeof id !== 'string') {\n    return false;\n  }\n\n  return emptyID(type) === id;\n}\n\n/**\n * Helper class for working with identifiers of a specific type.\n *\n * This class provides a convenient way to work with IDs without repeatedly\n * specifying the type parameter. Initialize it with your preferred ID type,\n * then use its methods without passing the type each time.\n *\n * @example\n * ```typescript\n * // Create a helper for UUID v7 identifiers\n * const idHelper = new IDHelpers('uuid7');\n *\n * // Generate IDs without specifying type each time\n * const id1 = idHelper.generateID();\n * const id2 = idHelper.generateID(Date.now());\n *\n * // Validate IDs\n * if (idHelper.validateID(someId)) {\n *   console.log('Valid uuid7');\n * }\n *\n * // Check for empty IDs\n * const empty = idHelper.emptyID();\n * console.log(idHelper.isEmptyID(empty));  // true\n * ```\n */\nexport class IDHelpers {\n  private _type: IdentifierType;\n\n  /**\n   * Gets the identifier type this helper is configured for.\n   */\n  public get type(): IdentifierType {\n    return this._type;\n  }\n\n  /**\n   * Creates a new ID helper for the specified type.\n   * @param type - The identifier type to use for all operations\n   * @throws {TypeError} If an invalid type is provided\n   */\n  constructor(type: IdentifierType) {\n    assertIdentifierType(type);\n    this._type = type;\n  }\n\n  /**\n   * Generates a new identifier using the configured type.\n   * @param seedTime - Optional timestamp in milliseconds to seed the ID with\n   * @returns A unique identifier string\n   */\n  public generateID(seedTime?: number): string {\n    return generateID(this._type, seedTime);\n  }\n\n  /**\n   * Validates an identifier against the configured type.\n   * @param id - The identifier string to validate\n   * @returns `true` if valid, `false` otherwise\n   */\n  public validateID(id: string): boolean {\n    return validateID(this._type, id);\n  }\n\n  /**\n   * Returns an empty identifier for the configured type.\n   * @returns An empty identifier string\n   */\n  public emptyID(): string {\n    return emptyID(this._type);\n  }\n\n  /**\n   * Checks if an identifier is empty for the configured type.\n   * @param id - The identifier string to check\n   * @returns `true` if empty, `false` otherwise\n   */\n  public isEmptyID(id: string): boolean {\n    return isEmptyID(this._type, id);\n  }\n}\n","/**\n * Returns the current unix time in seconds\n *\n * ```typescript\n * const time = unix();\n * ```\n */\n\nexport function unix(): number {\n  return Math.floor(Date.now() / 1000);\n}\n\n/**\n * Returns the current unix time in milliseconds\n *\n *  ```typescript\n * const time = ms();\n * ```\n */\n\nexport function ms(): number {\n  return Date.now();\n}\n\n/**\n * Returns a high resolution timestamp\n * Returns the time measured in milliseconds\n * This is aimed at performance monitoring\n *\n * ```typescript\n * const time = performance();\n * ```\n */\n\nexport function performance(): number {\n  return globalThis.performance.now();\n}\n\n/**\n * Converts a Unix timestamp from milliseconds to seconds.\n * Useful for converting the millisecond-based timestamp from JavaScript's Date.now() into a Unix timestamp in seconds.\n *\n * @param {number} value - Unix timestamp in milliseconds.\n * @returns {number} - Unix timestamp converted to seconds.\n *\n * ```typescript\n * convertMSToUnix(1593189055006); // returns 1593189055\n * ```\n */\n\nexport function convertMSToUnix(value: number): number {\n  return Math.floor(value / 1000);\n}\n\n/**\n * Converts a Unix timestamp from seconds to milliseconds.\n *\n * This function takes a Unix timestamp in seconds and converts it to milliseconds.\n * This is useful when dealing with JavaScript's Date object or other systems that\n * require time in milliseconds.\n *\n * @param {number} value - The Unix timestamp in seconds.\n * @returns {number} The Unix timestamp in milliseconds.\n *\n * Example:\n * ```typescript\n * convertUnix(1593189055); // returns 1593189055000\n * ```\n */\n\nexport function convertUnixToMS(value: number): number {\n  return value * 1000;\n}\n"],"mappings":"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","names":[]}

package/dist/lib/is-boolean.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/is-boolean.ts
+var is_boolean_exports = {};
+__export(is_boolean_exports, {
+  isBoolean: () => isBoolean
+});
+module.exports = __toCommonJS(is_boolean_exports);
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isBoolean
+});
+//# sourceMappingURL=is-boolean.cjs.map

package/dist/lib/is-boolean.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/is-boolean.ts"],"sourcesContent":["/**\n * Type guard to check if a value is a boolean.\n *\n * @param value - Value to check\n * @returns `true` if the value is a boolean, `false` otherwise\n *\n * @example\n * ```typescript\n * isBoolean(true);       // true\n * isBoolean(false);      // true\n * isBoolean(1);          // false\n * isBoolean('true');     // false\n * isBoolean(null);       // false\n * isBoolean(undefined);  // false\n * ```\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,SAAS,UAAU,OAAkC;AAC1D,SAAO,OAAO,UAAU;AAC1B;","names":[]}

package/dist/lib/is-boolean.d.cts

@@ -0,0 +1,19 @@
+/**
+ * Type guard to check if a value is a boolean.
+ *
+ * @param value - Value to check
+ * @returns `true` if the value is a boolean, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isBoolean(true);       // true
+ * isBoolean(false);      // true
+ * isBoolean(1);          // false
+ * isBoolean('true');     // false
+ * isBoolean(null);       // false
+ * isBoolean(undefined);  // false
+ * ```
+ */
+declare function isBoolean(value: unknown): value is boolean;
+
+export { isBoolean };

package/dist/lib/is-boolean.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Type guard to check if a value is a boolean.
+ *
+ * @param value - Value to check
+ * @returns `true` if the value is a boolean, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isBoolean(true);       // true
+ * isBoolean(false);      // true
+ * isBoolean(1);          // false
+ * isBoolean('true');     // false
+ * isBoolean(null);       // false
+ * isBoolean(undefined);  // false
+ * ```
+ */
+declare function isBoolean(value: unknown): value is boolean;
+
+export { isBoolean };

package/dist/lib/is-boolean.js

@@ -0,0 +1,8 @@
+// src/lib/is-boolean.ts
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+export {
+  isBoolean
+};
+//# sourceMappingURL=is-boolean.js.map

package/dist/lib/is-boolean.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/is-boolean.ts"],"sourcesContent":["/**\n * Type guard to check if a value is a boolean.\n *\n * @param value - Value to check\n * @returns `true` if the value is a boolean, `false` otherwise\n *\n * @example\n * ```typescript\n * isBoolean(true);       // true\n * isBoolean(false);      // true\n * isBoolean(1);          // false\n * isBoolean('true');     // false\n * isBoolean(null);       // false\n * isBoolean(undefined);  // false\n * ```\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n"],"mappings":";AAgBO,SAAS,UAAU,OAAkC;AAC1D,SAAO,OAAO,UAAU;AAC1B;","names":[]}

package/dist/lib/is-function.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/is-function.ts
+var is_function_exports = {};
+__export(is_function_exports, {
+  isFunction: () => isFunction
+});
+module.exports = __toCommonJS(is_function_exports);
+function isFunction(value) {
+  return typeof value === "function" || value instanceof Function;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isFunction
+});
+//# sourceMappingURL=is-function.cjs.map

package/dist/lib/is-function.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/is-function.ts"],"sourcesContent":["export function isFunction(value: unknown): boolean {\n  return typeof value === 'function' || value instanceof Function;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,SAAS,WAAW,OAAyB;AAClD,SAAO,OAAO,UAAU,cAAc,iBAAiB;AACzD;","names":[]}

package/dist/lib/is-function.d.cts

@@ -0,0 +1,3 @@
+declare function isFunction(value: unknown): boolean;
+
+export { isFunction };

package/dist/lib/is-function.d.ts

@@ -0,0 +1,3 @@
+declare function isFunction(value: unknown): boolean;
+
+export { isFunction };

package/dist/lib/is-function.js

@@ -0,0 +1,8 @@
+// src/lib/is-function.ts
+function isFunction(value) {
+  return typeof value === "function" || value instanceof Function;
+}
+export {
+  isFunction
+};
+//# sourceMappingURL=is-function.js.map

package/dist/lib/is-function.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/is-function.ts"],"sourcesContent":["export function isFunction(value: unknown): boolean {\n  return typeof value === 'function' || value instanceof Function;\n}\n"],"mappings":";AAAO,SAAS,WAAW,OAAyB;AAClD,SAAO,OAAO,UAAU,cAAc,iBAAiB;AACzD;","names":[]}

package/dist/lib/is-number.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/is-number.ts
+var is_number_exports = {};
+__export(is_number_exports, {
+  isFiniteNumber: () => isFiniteNumber,
+  isNumber: () => isNumber
+});
+module.exports = __toCommonJS(is_number_exports);
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && isFinite(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isFiniteNumber,
+  isNumber
+});
+//# sourceMappingURL=is-number.cjs.map

package/dist/lib/is-number.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/is-number.ts"],"sourcesContent":["/**\n * Type guard to check if a value is a valid number.\n *\n * @param value - Value to check\n * @returns `true` if the value is a number and not NaN, `false` otherwise\n *\n * @example\n * ```typescript\n * isNumber(42);        // true\n * isNumber(3.14);      // true\n * isNumber(NaN);       // false\n * isNumber('123');     // false\n * isNumber(null);      // false\n * isNumber(undefined); // false\n * ```\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number' && !isNaN(value);\n}\n\n/**\n * Type guard to check if a value is a finite number.\n *\n * @param value - Value to check\n * @returns `true` if the value is a number and is finite (excludes NaN, Infinity, -Infinity), `false` otherwise\n *\n * @example\n * ```typescript\n * isFiniteNumber(42);        // true\n * isFiniteNumber(3.14);      // true\n * isFiniteNumber(Infinity);  // false\n * isFiniteNumber(-Infinity); // false\n * isFiniteNumber(NaN);       // false\n * isFiniteNumber('123');     // false\n * isFiniteNumber(null);      // false\n * isFiniteNumber(undefined); // false\n * ```\n */\nexport function isFiniteNumber(value: unknown): value is number {\n  return typeof value === 'number' && isFinite(value);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU,YAAY,CAAC,MAAM,KAAK;AAClD;AAoBO,SAAS,eAAe,OAAiC;AAC9D,SAAO,OAAO,UAAU,YAAY,SAAS,KAAK;AACpD;","names":[]}

package/dist/lib/is-number.d.cts

@@ -0,0 +1,38 @@
+/**
+ * Type guard to check if a value is a valid number.
+ *
+ * @param value - Value to check
+ * @returns `true` if the value is a number and not NaN, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isNumber(42);        // true
+ * isNumber(3.14);      // true
+ * isNumber(NaN);       // false
+ * isNumber('123');     // false
+ * isNumber(null);      // false
+ * isNumber(undefined); // false
+ * ```
+ */
+declare function isNumber(value: unknown): value is number;
+/**
+ * Type guard to check if a value is a finite number.
+ *
+ * @param value - Value to check
+ * @returns `true` if the value is a number and is finite (excludes NaN, Infinity, -Infinity), `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isFiniteNumber(42);        // true
+ * isFiniteNumber(3.14);      // true
+ * isFiniteNumber(Infinity);  // false
+ * isFiniteNumber(-Infinity); // false
+ * isFiniteNumber(NaN);       // false
+ * isFiniteNumber('123');     // false
+ * isFiniteNumber(null);      // false
+ * isFiniteNumber(undefined); // false
+ * ```
+ */
+declare function isFiniteNumber(value: unknown): value is number;
+
+export { isFiniteNumber, isNumber };