@digitaldefiance/branded-enum 0.0.1

package/dist/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/lib/utils.js

@@ -0,0 +1,161 @@
+/**
+ * Utility functions for branded enums.
+ *
+ * Provides additional functionality beyond standard enum operations,
+ * including reverse lookup, key validation, and iteration.
+ */ import { ENUM_ID, ENUM_VALUES } from './types.js';
+/**
+ * Checks if an object is a branded enum (has Symbol metadata).
+ *
+ * @param obj - The object to check
+ * @returns true if obj is a branded enum
+ */ function isBrandedEnum(obj) {
+    return obj !== null && typeof obj === 'object' && ENUM_ID in obj && ENUM_VALUES in obj && typeof obj[ENUM_ID] === 'string' && obj[ENUM_VALUES] instanceof Set;
+}
+/**
+ * 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 function hasValue(enumObj, value) {
+    if (!isBrandedEnum(enumObj)) {
+        return false;
+    }
+    if (typeof value !== 'string') {
+        return false;
+    }
+    return enumObj[ENUM_VALUES].has(value);
+}
+/**
+ * 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 function getKeyForValue(enumObj, value) {
+    if (!isBrandedEnum(enumObj)) {
+        return undefined;
+    }
+    for (const key of Object.keys(enumObj)){
+        if (enumObj[key] === value) {
+            return key;
+        }
+    }
+    return 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 function isValidKey(enumObj, key) {
+    if (!isBrandedEnum(enumObj)) {
+        return false;
+    }
+    if (typeof key !== 'string') {
+        return false;
+    }
+    return Object.prototype.hasOwnProperty.call(enumObj, key);
+}
+/**
+ * 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 function* enumEntries(enumObj) {
+    if (!isBrandedEnum(enumObj)) {
+        return;
+    }
+    for (const [key, value] of Object.entries(enumObj)){
+        yield [
+            key,
+            value
+        ];
+    }
+}
+
+//# sourceMappingURL=utils.js.map

package/dist/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/dist/package.json

@@ -0,0 +1,120 @@
+{
+  "name": "@digitaldefiance/branded-enum",
+  "version": "0.0.1",
+  "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",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Digital-Defiance/branded-enum.git"
+  },
+  "keywords": [
+    "typescript",
+    "enum",
+    "branded",
+    "type-safe",
+    "runtime"
+  ],
+  "author": "Digital Defiance, Jessica Mulein",
+  "bugs": {
+    "url": "https://github.com/Digital-Defiance/branded-enum/issues"
+  },
+  "homepage": "https://github.com/Digital-Defiance/branded-enum#readme",
+  "scripts": {
+    "build": "nx build branded-enum",
+    "build:examples": "nx build-examples branded-enum",
+    "test": "nx test branded-enum",
+    "lint": "nx lint branded-enum",
+    "publish:public": "yarn build && npm publish --access public"
+  },
+  "devDependencies": {
+    "@nx/jest": "22.4.2",
+    "@nx/js": "22.4.2",
+    "@swc-node/register": "~1.9.1",
+    "@swc/cli": "~0.6.0",
+    "@swc/core": "~1.5.7",
+    "@swc/helpers": "~0.5.11",
+    "@swc/jest": "~0.2.38",
+    "@types/jest": "^30.0.0",
+    "@types/node": "20.19.9",
+    "fast-check": "^4.5.3",
+    "jest": "^30.0.2",
+    "jest-environment-node": "^30.0.2",
+    "jest-util": "^30.0.2",
+    "nx": "22.4.2",
+    "prettier": "~3.6.2",
+    "ts-jest": "^29.4.0",
+    "ts-node": "10.9.1",
+    "tslib": "^2.3.0",
+    "typescript": "~5.9.2"
+  },
+  "packageManager": "yarn@4.12.0",
+  "nx": {
+    "name": "branded-enum",
+    "sourceRoot": "src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "dist",
+          "main": "src/index.ts",
+          "tsConfig": "tsconfig.lib.json",
+          "skipTypeCheck": true,
+          "stripLeadingPaths": true
+        }
+      },
+      "test": {
+        "executor": "@nx/jest:jest",
+        "outputs": [
+          "{projectRoot}/test-output/jest/coverage"
+        ],
+        "options": {
+          "jestConfig": "jest.config.cts",
+          "passWithNoTests": true
+        }
+      },
+      "build-examples": {
+        "executor": "nx:run-commands",
+        "outputs": [
+          "{projectRoot}/examples/dist"
+        ],
+        "options": {
+          "command": "tsc -p examples/tsconfig.json"
+        },
+        "dependsOn": [
+          "build"
+        ]
+      },
+      "publish-public": {
+        "executor": "nx:run-commands",
+        "options": {
+          "command": "npm publish --access public"
+        },
+        "dependsOn": [
+          "build"
+        ]
+      }
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@digitaldefiance/branded-enum",
+  "version": "0.0.1",
+  "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",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Digital-Defiance/branded-enum.git"
+  },
+  "keywords": [
+    "typescript",
+    "enum",
+    "branded",
+    "type-safe",
+    "runtime"
+  ],
+  "author": "Digital Defiance, Jessica Mulein",
+  "bugs": {
+    "url": "https://github.com/Digital-Defiance/branded-enum/issues"
+  },
+  "homepage": "https://github.com/Digital-Defiance/branded-enum#readme",
+  "scripts": {
+    "build": "nx build branded-enum",
+    "build:examples": "nx build-examples branded-enum",
+    "test": "nx test branded-enum",
+    "lint": "nx lint branded-enum",
+    "publish:public": "yarn build && npm publish --access public"
+  },
+  "devDependencies": {
+    "@nx/jest": "22.4.2",
+    "@nx/js": "22.4.2",
+    "@swc-node/register": "~1.9.1",
+    "@swc/cli": "~0.6.0",
+    "@swc/core": "~1.5.7",
+    "@swc/helpers": "~0.5.11",
+    "@swc/jest": "~0.2.38",
+    "@types/jest": "^30.0.0",
+    "@types/node": "20.19.9",
+    "fast-check": "^4.5.3",
+    "jest": "^30.0.2",
+    "jest-environment-node": "^30.0.2",
+    "jest-util": "^30.0.2",
+    "nx": "22.4.2",
+    "prettier": "~3.6.2",
+    "ts-jest": "^29.4.0",
+    "ts-node": "10.9.1",
+    "tslib": "^2.3.0",
+    "typescript": "~5.9.2"
+  },
+  "packageManager": "yarn@4.12.0",
+  "nx": {
+    "name": "branded-enum",
+    "sourceRoot": "src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": ["{options.outputPath}"],
+        "options": {
+          "outputPath": "dist",
+          "main": "src/index.ts",
+          "tsConfig": "tsconfig.lib.json",
+          "skipTypeCheck": true,
+          "stripLeadingPaths": true
+        }
+      },
+      "test": {
+        "executor": "@nx/jest:jest",
+        "outputs": ["{projectRoot}/test-output/jest/coverage"],
+        "options": {
+          "jestConfig": "jest.config.cts",
+          "passWithNoTests": true
+        }
+      },
+      "build-examples": {
+        "executor": "nx:run-commands",
+        "outputs": ["{projectRoot}/examples/dist"],
+        "options": {
+          "command": "tsc -p examples/tsconfig.json"
+        },
+        "dependsOn": ["build"]
+      },
+      "publish-public": {
+        "executor": "nx:run-commands",
+        "options": {
+          "command": "npm publish --access public"
+        },
+        "dependsOn": ["build"]
+      }
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}