@digitaldefiance/branded-enum 0.0.1 → 0.0.3

package/dist/esm/lib/types.d.ts

@@ -0,0 +1,258 @@
+/**
+ * Core type definitions for branded-enum library
+ *
+ * These types enable runtime-identifiable enum-like objects in TypeScript
+ * with zero runtime overhead for value access.
+ */
+/**
+ * Symbol key for storing the enum ID metadata.
+ * Using a Symbol prevents collision with user-defined keys.
+ */
+export declare const ENUM_ID: unique symbol;
+/**
+ * Symbol key for storing the enum values Set.
+ * Using a Symbol prevents collision with user-defined keys.
+ */
+export declare const ENUM_VALUES: unique symbol;
+/**
+ * Metadata attached to branded enums via Symbol properties.
+ * These properties are non-enumerable and won't appear in
+ * Object.keys(), Object.values(), or JSON serialization.
+ */
+export interface BrandedEnumMetadata {
+    readonly [ENUM_ID]: string;
+    readonly [ENUM_VALUES]: Set<string>;
+}
+/**
+ * A branded enum object - combines the user's values object with metadata.
+ * The object is frozen (Readonly) to prevent modification after creation.
+ *
+ * @template T - The shape of the enum values object (Record<string, string>)
+ */
+export type BrandedEnum<T extends Record<string, string>> = Readonly<T> & BrandedEnumMetadata;
+/**
+ * Base constraint type for branded enums that works with both
+ * `as const` objects and regular Record<string, string> objects.
+ *
+ * This type is more permissive than `BrandedEnum<Record<string, string>>`
+ * and allows literal types from `as const` assertions.
+ */
+export type AnyBrandedEnum = {
+    readonly [ENUM_ID]: string;
+    readonly [ENUM_VALUES]: Set<string>;
+};
+/**
+ * Utility type to extract the union of all value types from a branded enum.
+ * Useful for typing variables that can hold any value from the enum.
+ *
+ * @template E - A BrandedEnum type
+ *
+ * @example
+ * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);
+ * type StatusValue = BrandedEnumValue<typeof Status>; // 'active' | 'inactive'
+ */
+export type BrandedEnumValue<E extends AnyBrandedEnum> = E extends BrandedEnum<infer T> ? T[keyof T] : never;
+/**
+ * Registry entry for tracking a single branded enum in the global registry.
+ */
+export interface RegistryEntry {
+    /** The unique identifier for this enum */
+    readonly enumId: string;
+    /** The branded enum object itself */
+    readonly enumObj: BrandedEnum<Record<string, string>>;
+    /** Set of all values in this enum for O(1) lookup */
+    readonly values: Set<string>;
+}
+/**
+ * Global registry structure stored on globalThis.
+ * Enables cross-bundle tracking of all branded enums.
+ */
+export interface BrandedEnumRegistry {
+    /** Map from enumId to registry entry */
+    readonly enums: Map<string, RegistryEntry>;
+    /** Reverse index: value -> Set of enumIds containing that value */
+    readonly valueIndex: Map<string, Set<string>>;
+}
+/**
+ * The key used to store the registry on globalThis.
+ * Namespaced to avoid collisions with other libraries.
+ */
+export declare const REGISTRY_KEY: "__brandedEnumRegistry__";
+/**
+ * The key used to store the enum consumer registry on globalThis.
+ * Tracks which classes consume which branded enums.
+ */
+export declare const CONSUMER_REGISTRY_KEY: "__brandedEnumConsumerRegistry__";
+/**
+ * Entry tracking a class that consumes branded enums.
+ */
+export interface EnumConsumerEntry {
+    /** The class constructor function */
+    readonly classRef: new (...args: any[]) => any;
+    /** The class name */
+    readonly className: string;
+    /** Set of enum IDs that this class consumes */
+    readonly enumIds: Set<string>;
+}
+/**
+ * Global registry for tracking enum consumers (classes decorated with @EnumClass).
+ * Enables debugging and introspection of enum usage across the codebase.
+ */
+export interface EnumConsumerRegistry {
+    /** Map from class name to consumer entry */
+    readonly consumers: Map<string, EnumConsumerEntry>;
+    /** Reverse index: enumId -> Set of class names consuming that enum */
+    readonly enumToConsumers: Map<string, Set<string>>;
+}
+/**
+ * Extracts the union of all keys from a branded enum.
+ *
+ * This utility type provides compile-time access to all key names of a branded enum,
+ * excluding the Symbol metadata keys (ENUM_ID and ENUM_VALUES).
+ *
+ * @template E - A BrandedEnum type
+ *
+ * @example
+ * const Status = createBrandedEnum('status', {
+ *   Active: 'active',
+ *   Inactive: 'inactive',
+ *   Pending: 'pending',
+ * } as const);
+ *
+ * type StatusKeys = EnumKeys<typeof Status>;
+ * // StatusKeys = 'Active' | 'Inactive' | 'Pending'
+ *
+ * @example
+ * // Use in function parameters
+ * function getStatusLabel<E extends AnyBrandedEnum>(
+ *   enumObj: E,
+ *   key: EnumKeys<E>
+ * ): string {
+ *   return enumObj[key] as string;
+ * }
+ */
+export type EnumKeys<E> = E extends BrandedEnum<infer T> ? keyof T & string : E extends AnyBrandedEnum ? Exclude<keyof E, typeof ENUM_ID | typeof ENUM_VALUES> & string : never;
+/**
+ * Extracts the union of all values from a branded enum.
+ *
+ * This is an alias for BrandedEnumValue that provides a more intuitive name
+ * when working with compile-time type utilities.
+ *
+ * @template E - A BrandedEnum type
+ *
+ * @example
+ * const Status = createBrandedEnum('status', {
+ *   Active: 'active',
+ *   Inactive: 'inactive',
+ *   Pending: 'pending',
+ * } as const);
+ *
+ * type StatusValues = EnumValues<typeof Status>;
+ * // StatusValues = 'active' | 'inactive' | 'pending'
+ *
+ * @example
+ * // Use for type-safe value handling
+ * function processStatus(value: EnumValues<typeof Status>) {
+ *   // value is 'active' | 'inactive' | 'pending'
+ * }
+ */
+export type EnumValues<E> = E extends BrandedEnum<infer T> ? T[keyof T] : E extends AnyBrandedEnum ? Exclude<E[Exclude<keyof E, typeof ENUM_ID | typeof ENUM_VALUES>], Set<string>> & string : never;
+/**
+ * Validates that a value type V is a valid value of branded enum E at compile time.
+ *
+ * If V is a valid value of E, this type resolves to V.
+ * If V is NOT a valid value of E, this type resolves to `never`, causing a compile error
+ * when used in contexts that expect a non-never type.
+ *
+ * This enables compile-time validation of enum values without runtime overhead.
+ *
+ * @template E - A BrandedEnum type
+ * @template V - The value type to validate
+ *
+ * @example
+ * const Status = createBrandedEnum('status', {
+ *   Active: 'active',
+ *   Inactive: 'inactive',
+ * } as const);
+ *
+ * // Valid - 'active' is in Status
+ * type Valid = ValidEnumValue<typeof Status, 'active'>; // 'active'
+ *
+ * // Invalid - 'unknown' is not in Status
+ * type Invalid = ValidEnumValue<typeof Status, 'unknown'>; // never
+ *
+ * @example
+ * // Use in function to enforce valid values at compile time
+ * function setStatus<V extends string>(
+ *   value: ValidEnumValue<typeof Status, V>
+ * ): void {
+ *   // Only compiles if value is 'active' | 'inactive'
+ * }
+ *
+ * setStatus('active'); // OK
+ * setStatus('inactive'); // OK
+ * // setStatus('unknown'); // Compile error: Argument of type 'never' is not assignable
+ *
+ * @example
+ * // Type-level assertion
+ * type AssertActive = ValidEnumValue<typeof Status, 'active'>; // 'active' - OK
+ * type AssertBad = ValidEnumValue<typeof Status, 'bad'>; // never - indicates invalid
+ */
+export type ValidEnumValue<E, V extends string> = V extends EnumValues<E> ? V : never;
+/**
+ * Creates a strict parameter type that only accepts valid values from a branded enum.
+ *
+ * This utility type is designed for function parameters where you want to enforce
+ * that only values from a specific branded enum are accepted at compile time.
+ *
+ * Unlike using `BrandedEnumValue<E>` directly, `StrictEnumParam` provides better
+ * error messages and works well with generic functions.
+ *
+ * @template E - A BrandedEnum type
+ *
+ * @example
+ * const Status = createBrandedEnum('status', {
+ *   Active: 'active',
+ *   Inactive: 'inactive',
+ *   Pending: 'pending',
+ * } as const);
+ *
+ * // Function that only accepts Status values
+ * function updateStatus(newStatus: StrictEnumParam<typeof Status>): void {
+ *   console.log(`Status updated to: ${newStatus}`);
+ * }
+ *
+ * updateStatus(Status.Active); // OK
+ * updateStatus('active'); // OK (literal type matches)
+ * // updateStatus('unknown'); // Compile error
+ *
+ * @example
+ * // Use with multiple enum parameters
+ * const Priority = createBrandedEnum('priority', {
+ *   High: 'high',
+ *   Medium: 'medium',
+ *   Low: 'low',
+ * } as const);
+ *
+ * function createTask(
+ *   status: StrictEnumParam<typeof Status>,
+ *   priority: StrictEnumParam<typeof Priority>
+ * ): void {
+ *   // Both parameters are type-safe
+ * }
+ *
+ * createTask(Status.Active, Priority.High); // OK
+ * createTask('active', 'high'); // OK
+ * // createTask('active', 'invalid'); // Compile error on second param
+ *
+ * @example
+ * // Generic function with strict enum constraint
+ * function processValue<E extends AnyBrandedEnum>(
+ *   enumObj: E,
+ *   value: StrictEnumParam<E>
+ * ): void {
+ *   // value is guaranteed to be a valid value of enumObj
+ * }
+ */
+export type StrictEnumParam<E> = EnumValues<E>;
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,OAAO,MAA0B,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,OAAO,MAA8B,CAAC;AAEhE;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,CAAC,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACrC;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GACrE,mBAAmB,CAAC;AAEtB;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,CAAC,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACrC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,cAAc,IACnD,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,KAAK,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qCAAqC;IACrC,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD,qDAAqD;IACrD,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC3C,mEAAmE;IACnE,QAAQ,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CAC/C;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAG,yBAAkC,CAAC;AAE/D;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAG,iCAA0C,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,qCAAqC;IAErC,QAAQ,CAAC,QAAQ,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;IAC/C,qBAAqB;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IACnD,sEAAsE;IACtE,QAAQ,CAAC,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CACpD;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,CAAC,GACpD,MAAM,CAAC,GAAG,MAAM,GAChB,CAAC,SAAS,cAAc,GACtB,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,OAAO,GAAG,OAAO,WAAW,CAAC,GAAG,MAAM,GAC9D,KAAK,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,CAAC,GACtD,CAAC,CAAC,MAAM,CAAC,CAAC,GACV,CAAC,SAAS,cAAc,GACtB,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,OAAO,GAAG,OAAO,WAAW,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,GACvF,KAAK,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,GACrE,CAAC,GACD,KAAK,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC"}

package/dist/esm/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/types.ts"],"sourcesContent":["/**\n * Core type definitions for branded-enum library\n *\n * These types enable runtime-identifiable enum-like objects in TypeScript\n * with zero runtime overhead for value access.\n */\n\n/**\n * Symbol key for storing the enum ID metadata.\n * Using a Symbol prevents collision with user-defined keys.\n */\nexport const ENUM_ID: unique symbol = Symbol('ENUM_ID');\n\n/**\n * Symbol key for storing the enum values Set.\n * Using a Symbol prevents collision with user-defined keys.\n */\nexport const ENUM_VALUES: unique symbol = Symbol('ENUM_VALUES');\n\n/**\n * Metadata attached to branded enums via Symbol properties.\n * These properties are non-enumerable and won't appear in\n * Object.keys(), Object.values(), or JSON serialization.\n */\nexport interface BrandedEnumMetadata {\n  readonly [ENUM_ID]: string;\n  readonly [ENUM_VALUES]: Set<string>;\n}\n\n/**\n * A branded enum object - combines the user's values object with metadata.\n * The object is frozen (Readonly) to prevent modification after creation.\n *\n * @template T - The shape of the enum values object (Record<string, string>)\n */\nexport type BrandedEnum<T extends Record<string, string>> = Readonly<T> &\n  BrandedEnumMetadata;\n\n/**\n * Base constraint type for branded enums that works with both\n * `as const` objects and regular Record<string, string> objects.\n *\n * This type is more permissive than `BrandedEnum<Record<string, string>>`\n * and allows literal types from `as const` assertions.\n */\nexport type AnyBrandedEnum = {\n  readonly [ENUM_ID]: string;\n  readonly [ENUM_VALUES]: Set<string>;\n};\n\n/**\n * Utility type to extract the union of all value types from a branded enum.\n * Useful for typing variables that can hold any value from the enum.\n *\n * @template E - A BrandedEnum type\n *\n * @example\n * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);\n * type StatusValue = BrandedEnumValue<typeof Status>; // 'active' | 'inactive'\n */\nexport type BrandedEnumValue<E extends AnyBrandedEnum> =\n  E extends BrandedEnum<infer T> ? T[keyof T] : never;\n\n/**\n * Registry entry for tracking a single branded enum in the global registry.\n */\nexport interface RegistryEntry {\n  /** The unique identifier for this enum */\n  readonly enumId: string;\n  /** The branded enum object itself */\n  readonly enumObj: BrandedEnum<Record<string, string>>;\n  /** Set of all values in this enum for O(1) lookup */\n  readonly values: Set<string>;\n}\n\n/**\n * Global registry structure stored on globalThis.\n * Enables cross-bundle tracking of all branded enums.\n */\nexport interface BrandedEnumRegistry {\n  /** Map from enumId to registry entry */\n  readonly enums: Map<string, RegistryEntry>;\n  /** Reverse index: value -> Set of enumIds containing that value */\n  readonly valueIndex: Map<string, Set<string>>;\n}\n\n/**\n * The key used to store the registry on globalThis.\n * Namespaced to avoid collisions with other libraries.\n */\nexport const REGISTRY_KEY = '__brandedEnumRegistry__' as const;\n\n/**\n * The key used to store the enum consumer registry on globalThis.\n * Tracks which classes consume which branded enums.\n */\nexport const CONSUMER_REGISTRY_KEY = '__brandedEnumConsumerRegistry__' as const;\n\n/**\n * Entry tracking a class that consumes branded enums.\n */\nexport interface EnumConsumerEntry {\n  /** The class constructor function */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  readonly classRef: new (...args: any[]) => any;\n  /** The class name */\n  readonly className: string;\n  /** Set of enum IDs that this class consumes */\n  readonly enumIds: Set<string>;\n}\n\n/**\n * Global registry for tracking enum consumers (classes decorated with @EnumClass).\n * Enables debugging and introspection of enum usage across the codebase.\n */\nexport interface EnumConsumerRegistry {\n  /** Map from class name to consumer entry */\n  readonly consumers: Map<string, EnumConsumerEntry>;\n  /** Reverse index: enumId -> Set of class names consuming that enum */\n  readonly enumToConsumers: Map<string, Set<string>>;\n}\n\n// =============================================================================\n// Compile-Time Validation Types\n// =============================================================================\n\n/**\n * Extracts the union of all keys from a branded enum.\n *\n * This utility type provides compile-time access to all key names of a branded enum,\n * excluding the Symbol metadata keys (ENUM_ID and ENUM_VALUES).\n *\n * @template E - A BrandedEnum type\n *\n * @example\n * const Status = createBrandedEnum('status', {\n *   Active: 'active',\n *   Inactive: 'inactive',\n *   Pending: 'pending',\n * } as const);\n *\n * type StatusKeys = EnumKeys<typeof Status>;\n * // StatusKeys = 'Active' | 'Inactive' | 'Pending'\n *\n * @example\n * // Use in function parameters\n * function getStatusLabel<E extends AnyBrandedEnum>(\n *   enumObj: E,\n *   key: EnumKeys<E>\n * ): string {\n *   return enumObj[key] as string;\n * }\n */\nexport type EnumKeys<E> = E extends BrandedEnum<infer T>\n  ? keyof T & string\n  : E extends AnyBrandedEnum\n    ? Exclude<keyof E, typeof ENUM_ID | typeof ENUM_VALUES> & string\n    : never;\n\n/**\n * Extracts the union of all values from a branded enum.\n *\n * This is an alias for BrandedEnumValue that provides a more intuitive name\n * when working with compile-time type utilities.\n *\n * @template E - A BrandedEnum type\n *\n * @example\n * const Status = createBrandedEnum('status', {\n *   Active: 'active',\n *   Inactive: 'inactive',\n *   Pending: 'pending',\n * } as const);\n *\n * type StatusValues = EnumValues<typeof Status>;\n * // StatusValues = 'active' | 'inactive' | 'pending'\n *\n * @example\n * // Use for type-safe value handling\n * function processStatus(value: EnumValues<typeof Status>) {\n *   // value is 'active' | 'inactive' | 'pending'\n * }\n */\nexport type EnumValues<E> = E extends BrandedEnum<infer T>\n  ? T[keyof T]\n  : E extends AnyBrandedEnum\n    ? Exclude<E[Exclude<keyof E, typeof ENUM_ID | typeof ENUM_VALUES>], Set<string>> & string\n    : never;\n\n/**\n * Validates that a value type V is a valid value of branded enum E at compile time.\n *\n * If V is a valid value of E, this type resolves to V.\n * If V is NOT a valid value of E, this type resolves to `never`, causing a compile error\n * when used in contexts that expect a non-never type.\n *\n * This enables compile-time validation of enum values without runtime overhead.\n *\n * @template E - A BrandedEnum type\n * @template V - The value type to validate\n *\n * @example\n * const Status = createBrandedEnum('status', {\n *   Active: 'active',\n *   Inactive: 'inactive',\n * } as const);\n *\n * // Valid - 'active' is in Status\n * type Valid = ValidEnumValue<typeof Status, 'active'>; // 'active'\n *\n * // Invalid - 'unknown' is not in Status\n * type Invalid = ValidEnumValue<typeof Status, 'unknown'>; // never\n *\n * @example\n * // Use in function to enforce valid values at compile time\n * function setStatus<V extends string>(\n *   value: ValidEnumValue<typeof Status, V>\n * ): void {\n *   // Only compiles if value is 'active' | 'inactive'\n * }\n *\n * setStatus('active'); // OK\n * setStatus('inactive'); // OK\n * // setStatus('unknown'); // Compile error: Argument of type 'never' is not assignable\n *\n * @example\n * // Type-level assertion\n * type AssertActive = ValidEnumValue<typeof Status, 'active'>; // 'active' - OK\n * type AssertBad = ValidEnumValue<typeof Status, 'bad'>; // never - indicates invalid\n */\nexport type ValidEnumValue<E, V extends string> = V extends EnumValues<E>\n  ? V\n  : never;\n\n/**\n * Creates a strict parameter type that only accepts valid values from a branded enum.\n *\n * This utility type is designed for function parameters where you want to enforce\n * that only values from a specific branded enum are accepted at compile time.\n *\n * Unlike using `BrandedEnumValue<E>` directly, `StrictEnumParam` provides better\n * error messages and works well with generic functions.\n *\n * @template E - A BrandedEnum type\n *\n * @example\n * const Status = createBrandedEnum('status', {\n *   Active: 'active',\n *   Inactive: 'inactive',\n *   Pending: 'pending',\n * } as const);\n *\n * // Function that only accepts Status values\n * function updateStatus(newStatus: StrictEnumParam<typeof Status>): void {\n *   console.log(`Status updated to: ${newStatus}`);\n * }\n *\n * updateStatus(Status.Active); // OK\n * updateStatus('active'); // OK (literal type matches)\n * // updateStatus('unknown'); // Compile error\n *\n * @example\n * // Use with multiple enum parameters\n * const Priority = createBrandedEnum('priority', {\n *   High: 'high',\n *   Medium: 'medium',\n *   Low: 'low',\n * } as const);\n *\n * function createTask(\n *   status: StrictEnumParam<typeof Status>,\n *   priority: StrictEnumParam<typeof Priority>\n * ): void {\n *   // Both parameters are type-safe\n * }\n *\n * createTask(Status.Active, Priority.High); // OK\n * createTask('active', 'high'); // OK\n * // createTask('active', 'invalid'); // Compile error on second param\n *\n * @example\n * // Generic function with strict enum constraint\n * function processValue<E extends AnyBrandedEnum>(\n *   enumObj: E,\n *   value: StrictEnumParam<E>\n * ): void {\n *   // value is guaranteed to be a valid value of enumObj\n * }\n */\nexport type StrictEnumParam<E> = EnumValues<E>;\n"],"names":["ENUM_ID","Symbol","ENUM_VALUES","REGISTRY_KEY","CONSUMER_REGISTRY_KEY"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;CAKC,GAED;;;CAGC,GACD,OAAO,MAAMA,UAAyBC,OAAO,WAAW;AAExD;;;CAGC,GACD,OAAO,MAAMC,cAA6BD,OAAO,eAAe;AAqEhE;;;CAGC,GACD,OAAO,MAAME,eAAe,0BAAmC;AAE/D;;;CAGC,GACD,OAAO,MAAMC,wBAAwB,kCAA2C"}

package/dist/esm/lib/utils.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Utility functions for branded enums.
+ *
+ * Provides additional functionality beyond standard enum operations,
+ * including reverse lookup, key validation, and iteration.
+ */
+import { AnyBrandedEnum, EnumKeys, EnumValues } from './types.js';
+/**
+ * Checks if a value exists in a branded enum (reverse lookup).
+ *
+ * Similar to `isFromEnum`, but with arguments in a different order that
+ * may be more natural for some use cases. Also provides type narrowing.
+ *
+ * @template E - The branded enum type
+ * @param enumObj - The branded enum to search in
+ * @param value - The value to check. Can be any type; non-strings return false.
+ * @returns `true` if the value exists in the enum (with type narrowing),
+ *   `false` otherwise. Returns `false` for non-string values or if
+ *   enumObj is not a branded enum.
+ *
+ * @example
+ * // Check if value exists
+ * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);
+ * hasValue(Status, 'active'); // true
+ * hasValue(Status, 'unknown'); // false
+ *
+ * @example
+ * // Returns false for non-string values
+ * hasValue(Status, 123); // false
+ * hasValue(Status, null); // false
+ */
+export declare function hasValue<E extends AnyBrandedEnum>(enumObj: E, value: unknown): value is EnumValues<E>;
+/**
+ * Gets the key name for a value in a branded enum.
+ *
+ * Performs a reverse lookup to find which key maps to a given value.
+ * If multiple keys have the same value, returns the first one found
+ * (order is not guaranteed).
+ *
+ * @template E - The branded enum type
+ * @param enumObj - The branded enum to search in
+ * @param value - The string value to look up
+ * @returns The key name that maps to the value, or `undefined` if the
+ *   value is not found or enumObj is not a branded enum.
+ *
+ * @example
+ * // Find key for value
+ * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);
+ * getKeyForValue(Status, 'active'); // 'Active'
+ * getKeyForValue(Status, 'inactive'); // 'Inactive'
+ *
+ * @example
+ * // Returns undefined for unknown values
+ * getKeyForValue(Status, 'unknown'); // undefined
+ *
+ * @example
+ * // Roundtrip: value -> key -> value
+ * const key = getKeyForValue(Status, 'active'); // 'Active'
+ * Status[key]; // 'active'
+ */
+export declare function getKeyForValue<E extends AnyBrandedEnum>(enumObj: E, value: string): EnumKeys<E> | undefined;
+/**
+ * Checks if a key exists in a branded enum.
+ *
+ * Validates whether a given key is a valid member of the enum.
+ * Returns false for Symbol keys (metadata) and non-string keys.
+ *
+ * @template E - The branded enum type
+ * @param enumObj - The branded enum to check
+ * @param key - The key to validate. Can be any type; non-strings return false.
+ * @returns `true` if the key exists in the enum (with type narrowing),
+ *   `false` otherwise. Returns `false` for metadata Symbol keys or if
+ *   enumObj is not a branded enum.
+ *
+ * @example
+ * // Check if key exists
+ * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);
+ * isValidKey(Status, 'Active'); // true
+ * isValidKey(Status, 'Inactive'); // true
+ * isValidKey(Status, 'Unknown'); // false
+ *
+ * @example
+ * // Returns false for non-string keys
+ * isValidKey(Status, 123); // false
+ * isValidKey(Status, Symbol('test')); // false
+ */
+export declare function isValidKey<E extends AnyBrandedEnum>(enumObj: E, key: unknown): key is EnumKeys<E>;
+/**
+ * Returns an iterator of [key, value] pairs for a branded enum.
+ *
+ * Provides a way to iterate over all key-value pairs in the enum using
+ * a for...of loop. Only yields user-defined entries, not metadata.
+ * Equivalent to `Object.entries(enumObj)` but with proper typing.
+ *
+ * @template E - The branded enum type
+ * @param enumObj - The branded enum to iterate over
+ * @returns An iterator yielding [key, value] tuples. Returns an empty
+ *   iterator if enumObj is not a branded enum.
+ *
+ * @example
+ * // Iterate over entries
+ * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);
+ *
+ * for (const [key, value] of enumEntries(Status)) {
+ *   console.log(`${key}: ${value}`);
+ * }
+ * // Output:
+ * // Active: active
+ * // Inactive: inactive
+ *
+ * @example
+ * // Convert to array
+ * const entries = [...enumEntries(Status)];
+ * // [['Active', 'active'], ['Inactive', 'inactive']]
+ *
+ * @example
+ * // Use with Array.from
+ * const entriesArray = Array.from(enumEntries(Status));
+ */
+export declare function enumEntries<E extends AnyBrandedEnum>(enumObj: E): IterableIterator<[EnumKeys<E>, EnumValues<E>]>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,cAAc,EAKd,QAAQ,EACR,UAAU,EACX,MAAM,YAAY,CAAC;AAmBpB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,cAAc,EAC/C,OAAO,EAAE,CAAC,EACV,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,CAQxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,cAAc,EACrD,OAAO,EAAE,CAAC,EACV,KAAK,EAAE,MAAM,GACZ,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAUzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,cAAc,EACjD,OAAO,EAAE,CAAC,EACV,GAAG,EAAE,OAAO,GACX,GAAG,IAAI,QAAQ,CAAC,CAAC,CAAC,CAQpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAiB,WAAW,CAAC,CAAC,SAAS,cAAc,EACnD,OAAO,EAAE,CAAC,GACT,gBAAgB,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAOhD"}

package/dist/esm/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/utils.ts"],"sourcesContent":["/**\n * Utility functions for branded enums.\n *\n * Provides additional functionality beyond standard enum operations,\n * including reverse lookup, key validation, and iteration.\n */\n\nimport {\n  AnyBrandedEnum,\n  BrandedEnum,\n  BrandedEnumValue,\n  ENUM_ID,\n  ENUM_VALUES,\n  EnumKeys,\n  EnumValues,\n} from './types.js';\n\n/**\n * Checks if an object is a branded enum (has Symbol metadata).\n *\n * @param obj - The object to check\n * @returns true if obj is a branded enum\n */\nfunction isBrandedEnum(obj: unknown): obj is AnyBrandedEnum {\n  return (\n    obj !== null &&\n    typeof obj === 'object' &&\n    ENUM_ID in obj &&\n    ENUM_VALUES in obj &&\n    typeof (obj as AnyBrandedEnum)[ENUM_ID] === 'string' &&\n    (obj as AnyBrandedEnum)[ENUM_VALUES] instanceof Set\n  );\n}\n\n/**\n * Checks if a value exists in a branded enum (reverse lookup).\n *\n * Similar to `isFromEnum`, but with arguments in a different order that\n * may be more natural for some use cases. Also provides type narrowing.\n *\n * @template E - The branded enum type\n * @param enumObj - The branded enum to search in\n * @param value - The value to check. Can be any type; non-strings return false.\n * @returns `true` if the value exists in the enum (with type narrowing),\n *   `false` otherwise. Returns `false` for non-string values or if\n *   enumObj is not a branded enum.\n *\n * @example\n * // Check if value exists\n * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);\n * hasValue(Status, 'active'); // true\n * hasValue(Status, 'unknown'); // false\n *\n * @example\n * // Returns false for non-string values\n * hasValue(Status, 123); // false\n * hasValue(Status, null); // false\n */\nexport function hasValue<E extends AnyBrandedEnum>(\n  enumObj: E,\n  value: unknown\n): value is EnumValues<E> {\n  if (!isBrandedEnum(enumObj)) {\n    return false;\n  }\n  if (typeof value !== 'string') {\n    return false;\n  }\n  return enumObj[ENUM_VALUES].has(value);\n}\n\n/**\n * Gets the key name for a value in a branded enum.\n *\n * Performs a reverse lookup to find which key maps to a given value.\n * If multiple keys have the same value, returns the first one found\n * (order is not guaranteed).\n *\n * @template E - The branded enum type\n * @param enumObj - The branded enum to search in\n * @param value - The string value to look up\n * @returns The key name that maps to the value, or `undefined` if the\n *   value is not found or enumObj is not a branded enum.\n *\n * @example\n * // Find key for value\n * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);\n * getKeyForValue(Status, 'active'); // 'Active'\n * getKeyForValue(Status, 'inactive'); // 'Inactive'\n *\n * @example\n * // Returns undefined for unknown values\n * getKeyForValue(Status, 'unknown'); // undefined\n *\n * @example\n * // Roundtrip: value -> key -> value\n * const key = getKeyForValue(Status, 'active'); // 'Active'\n * Status[key]; // 'active'\n */\nexport function getKeyForValue<E extends AnyBrandedEnum>(\n  enumObj: E,\n  value: string\n): EnumKeys<E> | undefined {\n  if (!isBrandedEnum(enumObj)) {\n    return undefined;\n  }\n  for (const key of Object.keys(enumObj)) {\n    if ((enumObj as Record<string, unknown>)[key] === value) {\n      return key as EnumKeys<E>;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Checks if a key exists in a branded enum.\n *\n * Validates whether a given key is a valid member of the enum.\n * Returns false for Symbol keys (metadata) and non-string keys.\n *\n * @template E - The branded enum type\n * @param enumObj - The branded enum to check\n * @param key - The key to validate. Can be any type; non-strings return false.\n * @returns `true` if the key exists in the enum (with type narrowing),\n *   `false` otherwise. Returns `false` for metadata Symbol keys or if\n *   enumObj is not a branded enum.\n *\n * @example\n * // Check if key exists\n * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);\n * isValidKey(Status, 'Active'); // true\n * isValidKey(Status, 'Inactive'); // true\n * isValidKey(Status, 'Unknown'); // false\n *\n * @example\n * // Returns false for non-string keys\n * isValidKey(Status, 123); // false\n * isValidKey(Status, Symbol('test')); // false\n */\nexport function isValidKey<E extends AnyBrandedEnum>(\n  enumObj: E,\n  key: unknown\n): key is EnumKeys<E> {\n  if (!isBrandedEnum(enumObj)) {\n    return false;\n  }\n  if (typeof key !== 'string') {\n    return false;\n  }\n  return Object.prototype.hasOwnProperty.call(enumObj, key);\n}\n\n/**\n * Returns an iterator of [key, value] pairs for a branded enum.\n *\n * Provides a way to iterate over all key-value pairs in the enum using\n * a for...of loop. Only yields user-defined entries, not metadata.\n * Equivalent to `Object.entries(enumObj)` but with proper typing.\n *\n * @template E - The branded enum type\n * @param enumObj - The branded enum to iterate over\n * @returns An iterator yielding [key, value] tuples. Returns an empty\n *   iterator if enumObj is not a branded enum.\n *\n * @example\n * // Iterate over entries\n * const Status = createBrandedEnum('status', { Active: 'active', Inactive: 'inactive' } as const);\n *\n * for (const [key, value] of enumEntries(Status)) {\n *   console.log(`${key}: ${value}`);\n * }\n * // Output:\n * // Active: active\n * // Inactive: inactive\n *\n * @example\n * // Convert to array\n * const entries = [...enumEntries(Status)];\n * // [['Active', 'active'], ['Inactive', 'inactive']]\n *\n * @example\n * // Use with Array.from\n * const entriesArray = Array.from(enumEntries(Status));\n */\nexport function* enumEntries<E extends AnyBrandedEnum>(\n  enumObj: E\n): IterableIterator<[EnumKeys<E>, EnumValues<E>]> {\n  if (!isBrandedEnum(enumObj)) {\n    return;\n  }\n  for (const [key, value] of Object.entries(enumObj)) {\n    yield [key as EnumKeys<E>, value as EnumValues<E>];\n  }\n}\n"],"names":["ENUM_ID","ENUM_VALUES","isBrandedEnum","obj","Set","hasValue","enumObj","value","has","getKeyForValue","undefined","key","Object","keys","isValidKey","prototype","hasOwnProperty","call","enumEntries","entries"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;CAKC,GAED,SAIEA,OAAO,EACPC,WAAW,QAGN,aAAa;AAEpB;;;;;CAKC,GACD,SAASC,cAAcC,GAAY;IACjC,OACEA,QAAQ,QACR,OAAOA,QAAQ,YACfH,WAAWG,OACXF,eAAeE,OACf,OAAO,AAACA,GAAsB,CAACH,QAAQ,KAAK,YAC5C,AAACG,GAAsB,CAACF,YAAY,YAAYG;AAEpD;AAEA;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GACD,OAAO,SAASC,SACdC,OAAU,EACVC,KAAc;IAEd,IAAI,CAACL,cAAcI,UAAU;QAC3B,OAAO;IACT;IACA,IAAI,OAAOC,UAAU,UAAU;QAC7B,OAAO;IACT;IACA,OAAOD,OAAO,CAACL,YAAY,CAACO,GAAG,CAACD;AAClC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BC,GACD,OAAO,SAASE,eACdH,OAAU,EACVC,KAAa;IAEb,IAAI,CAACL,cAAcI,UAAU;QAC3B,OAAOI;IACT;IACA,KAAK,MAAMC,OAAOC,OAAOC,IAAI,CAACP,SAAU;QACtC,IAAI,AAACA,OAAmC,CAACK,IAAI,KAAKJ,OAAO;YACvD,OAAOI;QACT;IACF;IACA,OAAOD;AACT;AAEA;;;;;;;;;;;;;;;;;;;;;;;;CAwBC,GACD,OAAO,SAASI,WACdR,OAAU,EACVK,GAAY;IAEZ,IAAI,CAACT,cAAcI,UAAU;QAC3B,OAAO;IACT;IACA,IAAI,OAAOK,QAAQ,UAAU;QAC3B,OAAO;IACT;IACA,OAAOC,OAAOG,SAAS,CAACC,cAAc,CAACC,IAAI,CAACX,SAASK;AACvD;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BC,GACD,OAAO,UAAUO,YACfZ,OAAU;IAEV,IAAI,CAACJ,cAAcI,UAAU;QAC3B;IACF;IACA,KAAK,MAAM,CAACK,KAAKJ,MAAM,IAAIK,OAAOO,OAAO,CAACb,SAAU;QAClD,MAAM;YAACK;YAAoBJ;SAAuB;IACpD;AACF"}

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "@digitaldefiance/branded-enum",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Runtime-identifiable enum-like types for TypeScript with zero runtime overhead",
   "license": "MIT",
   "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.cjs",
+      "default": "./dist/esm/index.js"
     }
   },
   "files": [
@@ -69,19 +70,25 @@
     "sourceRoot": "src",
     "targets": {
       "build": {
-        "executor": "@nx/js:swc",
-        "outputs": ["{options.outputPath}"],
+        "executor": "nx:run-commands",
+        "outputs": [
+          "{projectRoot}/dist"
+        ],
         "options": {
-          "outputPath": "dist",
-          "main": "src/index.ts",
-          "tsConfig": "tsconfig.lib.json",
-          "skipTypeCheck": true,
-          "stripLeadingPaths": true
+          "commands": [
+            "swc src -d dist/esm --config-file .swcrc --strip-leading-paths",
+            "swc src -d dist/cjs --config-file .swcrc.cjs --strip-leading-paths -C module.type=commonjs --out-file-extension cjs",
+            "tsc -p tsconfig.lib.json"
+          ],
+          "cwd": "{projectRoot}",
+          "parallel": false
         }
       },
       "test": {
         "executor": "@nx/jest:jest",
-        "outputs": ["{projectRoot}/test-output/jest/coverage"],
+        "outputs": [
+          "{projectRoot}/test-output/jest/coverage"
+        ],
         "options": {
           "jestConfig": "jest.config.cts",
           "passWithNoTests": true
@@ -89,18 +96,24 @@
       },
       "build-examples": {
         "executor": "nx:run-commands",
-        "outputs": ["{projectRoot}/examples/dist"],
+        "outputs": [
+          "{projectRoot}/examples/dist"
+        ],
         "options": {
           "command": "tsc -p examples/tsconfig.json"
         },
-        "dependsOn": ["build"]
+        "dependsOn": [
+          "build"
+        ]
       },
       "publish-public": {
         "executor": "nx:run-commands",
         "options": {
           "command": "npm publish --access public"
         },
-        "dependsOn": ["build"]
+        "dependsOn": [
+          "build"
+        ]
       }
     }
   },

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * branded-enum - Runtime-identifiable enum-like types for TypeScript\n *\n * This library provides enum-like objects with embedded metadata for runtime\n * identification, enabling you to determine which enum a string value belongs to.\n *\n * @packageDocumentation\n */\n\n// =============================================================================\n// Types\n// =============================================================================\n\nexport type {\n  BrandedEnumMetadata,\n  BrandedEnum,\n  BrandedEnumValue,\n  RegistryEntry,\n  BrandedEnumRegistry,\n  EnumConsumerEntry,\n  EnumConsumerRegistry,\n  AnyBrandedEnum,\n  EnumKeys,\n  EnumValues,\n  ValidEnumValue,\n  StrictEnumParam,\n} from './lib/types.js';\n\n// =============================================================================\n// Factory\n// =============================================================================\n\nexport { createBrandedEnum } from './lib/factory.js';\n\n// =============================================================================\n// Registry\n// =============================================================================\n\nexport {\n  getRegistry,\n  getAllEnumIds,\n  getEnumById,\n  findEnumSources,\n} from './lib/registry.js';\n\n// =============================================================================\n// Type Guards\n// =============================================================================\n\nexport { isFromEnum, assertFromEnum, parseEnum, safeParseEnum } from './lib/guards.js';\nexport type { SafeParseSuccess, SafeParseFailure, SafeParseError, SafeParseErrorCode, SafeParseResult } from './lib/guards.js';\n\n// =============================================================================\n// Metadata Accessors\n// =============================================================================\n\nexport { getEnumId, getEnumValues, enumSize } from './lib/accessors.js';\n\n// =============================================================================\n// Utility Functions\n// =============================================================================\n\nexport {\n  hasValue,\n  getKeyForValue,\n  isValidKey,\n  enumEntries,\n} from './lib/utils.js';\n\n// =============================================================================\n// Composition\n// =============================================================================\n\nexport { mergeEnums } from './lib/merge.js';\n\n// =============================================================================\n// Advanced Operations\n// =============================================================================\n\nexport { enumSubset, enumExclude, enumMap, enumFromKeys, enumDiff, enumIntersect, enumToRecord, watchEnum, watchAllEnums, clearAllEnumWatchers, getEnumWatcherCount, getGlobalWatcherCount, exhaustive, exhaustiveGuard, toJsonSchema, toZodSchema, enumSerializer } from './lib/advanced.js';\nexport type { EnumDiffResult, EnumIntersectEntry, EnumAccessType, EnumAccessEvent, EnumWatchCallback, WatchEnumResult, ToJsonSchemaOptions, EnumJsonSchema, ToZodSchemaOptions, ZodEnumSchemaDefinition, EnumSerializerOptions, DeserializeSuccess, DeserializeFailure, DeserializeResult, EnumSerializer } from './lib/advanced.js';\n\n// =============================================================================\n// Decorators\n// =============================================================================\n\nexport {\n  EnumValue,\n  EnumClass,\n  getEnumConsumers,\n  getConsumedEnums,\n  getAllEnumConsumers,\n} from './lib/decorators.js';\nexport type { EnumValueOptions } from './lib/decorators.js';\n"],"names":["createBrandedEnum","getRegistry","getAllEnumIds","getEnumById","findEnumSources","isFromEnum","assertFromEnum","parseEnum","safeParseEnum","getEnumId","getEnumValues","enumSize","hasValue","getKeyForValue","isValidKey","enumEntries","mergeEnums","enumSubset","enumExclude","enumMap","enumFromKeys","enumDiff","enumIntersect","enumToRecord","watchEnum","watchAllEnums","clearAllEnumWatchers","getEnumWatcherCount","getGlobalWatcherCount","exhaustive","exhaustiveGuard","toJsonSchema","toZodSchema","enumSerializer","EnumValue","EnumClass","getEnumConsumers","getConsumedEnums","getAllEnumConsumers"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;;;CAOC,GAED,gFAAgF;AAChF,QAAQ;AACR,gFAAgF;AAiBhF,gFAAgF;AAChF,UAAU;AACV,gFAAgF;AAEhF,SAASA,iBAAiB,QAAQ,mBAAmB;AAErD,gFAAgF;AAChF,WAAW;AACX,gFAAgF;AAEhF,SACEC,WAAW,EACXC,aAAa,EACbC,WAAW,EACXC,eAAe,QACV,oBAAoB;AAE3B,gFAAgF;AAChF,cAAc;AACd,gFAAgF;AAEhF,SAASC,UAAU,EAAEC,cAAc,EAAEC,SAAS,EAAEC,aAAa,QAAQ,kBAAkB;AAGvF,gFAAgF;AAChF,qBAAqB;AACrB,gFAAgF;AAEhF,SAASC,SAAS,EAAEC,aAAa,EAAEC,QAAQ,QAAQ,qBAAqB;AAExE,gFAAgF;AAChF,oBAAoB;AACpB,gFAAgF;AAEhF,SACEC,QAAQ,EACRC,cAAc,EACdC,UAAU,EACVC,WAAW,QACN,iBAAiB;AAExB,gFAAgF;AAChF,cAAc;AACd,gFAAgF;AAEhF,SAASC,UAAU,QAAQ,iBAAiB;AAE5C,gFAAgF;AAChF,sBAAsB;AACtB,gFAAgF;AAEhF,SAASC,UAAU,EAAEC,WAAW,EAAEC,OAAO,EAAEC,YAAY,EAAEC,QAAQ,EAAEC,aAAa,EAAEC,YAAY,EAAEC,SAAS,EAAEC,aAAa,EAAEC,oBAAoB,EAAEC,mBAAmB,EAAEC,qBAAqB,EAAEC,UAAU,EAAEC,eAAe,EAAEC,YAAY,EAAEC,WAAW,EAAEC,cAAc,QAAQ,oBAAoB;AAG9R,gFAAgF;AAChF,aAAa;AACb,gFAAgF;AAEhF,SACEC,SAAS,EACTC,SAAS,EACTC,gBAAgB,EAChBC,gBAAgB,EAChBC,mBAAmB,QACd,sBAAsB"}

package/dist/lib/accessors.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/lib/accessors.ts"],"sourcesContent":["/**\n * Metadata accessors for branded enums.\n *\n * Provides functions to retrieve metadata from branded enum objects,\n * including enum ID, values array, and size.\n */\n\nimport {\n  AnyBrandedEnum,\n  BrandedEnum,\n  BrandedEnumValue,\n  ENUM_ID,\n  ENUM_VALUES,\n  EnumValues,\n} from './types.js';\n\n/**\n * Checks if an object is a branded enum (has Symbol metadata).\n *\n * @param obj - The object to check\n * @returns true if obj is a branded enum\n */\nfunction isBrandedEnum(obj: unknown): obj is AnyBrandedEnum {\n  return (\n    obj !== null &&\n    typeof obj === 'object' &&\n    ENUM_ID in obj &&\n    ENUM_VALUES in obj &&\n    typeof (obj as AnyBrandedEnum)[ENUM_ID] === 'string' &&\n    (obj as AnyBrandedEnum)[ENUM_VALUES] instanceof Set\n  );\n}\n\n/**\n * Gets the enum ID from a branded enum.\n *\n * Retrieves the unique identifier that was assigned when the enum was created.\n * Returns undefined for objects that are not branded enums.\n *\n * @param enumObj - The object to get the enum ID from. Can be any type.\n * @returns The enum ID string if enumObj is a branded enum, `undefined` otherwise.\n *\n * @example\n * // Get ID from branded enum\n * const Status = createBrandedEnum('status', { Active: 'active' } as const);\n * getEnumId(Status); // 'status'\n *\n * @example\n * // Returns undefined for non-branded objects\n * getEnumId({}); // undefined\n * getEnumId({ Active: 'active' }); // undefined\n * getEnumId(null); // undefined\n */\nexport function getEnumId(enumObj: unknown): string | undefined {\n  if (!isBrandedEnum(enumObj)) {\n    return undefined;\n  }\n  return enumObj[ENUM_ID];\n}\n\n/**\n * Gets all values from a branded enum as an array.\n *\n * Returns an array containing all the string values in the enum.\n * The order of values is not guaranteed.\n *\n * @template E - The branded enum type\n * @param enumObj - The object to get values from. Can be any type.\n * @returns Array of all enum values if enumObj is a branded enum,\n *   `undefined` otherwise.\n *\n * @example\n * // Get values from branded enum\n * const Status = createBrandedEnum('status', {\n *   Active: 'active',\n *   Inactive: 'inactive'\n * } as const);\n * getEnumValues(Status); // ['active', 'inactive']\n *\n * @example\n * // Returns undefined for non-branded objects\n * getEnumValues({}); // undefined\n * getEnumValues({ Active: 'active' }); // undefined\n */\nexport function getEnumValues<E extends AnyBrandedEnum>(\n  enumObj: E\n): EnumValues<E>[] | undefined;\nexport function getEnumValues(enumObj: unknown): string[] | undefined;\nexport function getEnumValues(enumObj: unknown): string[] | undefined {\n  if (!isBrandedEnum(enumObj)) {\n    return undefined;\n  }\n  return Array.from(enumObj[ENUM_VALUES]);\n}\n\n/**\n * Gets the number of values in a branded enum.\n *\n * Returns the count of unique values in the enum. This is equivalent to\n * the number of key-value pairs defined when the enum was created.\n *\n * @param enumObj - The object to get the size of. Can be any type.\n * @returns The number of values in the enum if enumObj is a branded enum,\n *   `undefined` otherwise.\n *\n * @example\n * // Get size of branded enum\n * const Status = createBrandedEnum('status', {\n *   Active: 'active',\n *   Inactive: 'inactive'\n * } as const);\n * enumSize(Status); // 2\n *\n * @example\n * // Returns undefined for non-branded objects\n * enumSize({}); // undefined\n * enumSize({ Active: 'active' }); // undefined\n */\nexport function enumSize(enumObj: unknown): number | undefined {\n  if (!isBrandedEnum(enumObj)) {\n    return undefined;\n  }\n  return enumObj[ENUM_VALUES].size;\n}\n"],"names":["ENUM_ID","ENUM_VALUES","isBrandedEnum","obj","Set","getEnumId","enumObj","undefined","getEnumValues","Array","from","enumSize","size"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;;CAKC,GAED,SAIEA,OAAO,EACPC,WAAW,QAEN,aAAa;AAEpB;;;;;CAKC,GACD,SAASC,cAAcC,GAAY;IACjC,OACEA,QAAQ,QACR,OAAOA,QAAQ,YACfH,WAAWG,OACXF,eAAeE,OACf,OAAO,AAACA,GAAsB,CAACH,QAAQ,KAAK,YAC5C,AAACG,GAAsB,CAACF,YAAY,YAAYG;AAEpD;AAEA;;;;;;;;;;;;;;;;;;;CAmBC,GACD,OAAO,SAASC,UAAUC,OAAgB;IACxC,IAAI,CAACJ,cAAcI,UAAU;QAC3B,OAAOC;IACT;IACA,OAAOD,OAAO,CAACN,QAAQ;AACzB;AA8BA,OAAO,SAASQ,cAAcF,OAAgB;IAC5C,IAAI,CAACJ,cAAcI,UAAU;QAC3B,OAAOC;IACT;IACA,OAAOE,MAAMC,IAAI,CAACJ,OAAO,CAACL,YAAY;AACxC;AAEA;;;;;;;;;;;;;;;;;;;;;;CAsBC,GACD,OAAO,SAASU,SAASL,OAAgB;IACvC,IAAI,CAACJ,cAAcI,UAAU;QAC3B,OAAOC;IACT;IACA,OAAOD,OAAO,CAACL,YAAY,CAACW,IAAI;AAClC"}