@xylabs/enum 4.12.44 → 4.13.1

package/dist/{types/Enum.d.ts → neutral/index.d.ts}

@@ -1,84 +1,87 @@
-/**
- * Transforms a given record object into a readonly "enum-like" structure while preserving
- * the literal types of its values. This allows you to use the returned object both at runtime
- * (for lookups) and at compile time (for strongly typed values).
- *
- * To maintain literal types (i.e., prevent them from being widened to `string`, `number`, etc.),
- * ensure you annotate your object with `as const` before passing it to `Enum`.
- *
- * @template T - A record type with string keys and any kind of values.
- * @param obj - A readonly record object annotated with `as const`.
- * @returns A readonly version of the provided record, preserving exact literal value types.
- *
- * @example
- * ```typescript
- * // Defining a record with literal types using as const:
- * const DnsRecordType = Enum({
- *   A: 1,
- *   AAAA: 28,
- *   CAA: 257,
- *   CNAME: 5,
- *   DNAME: 39,
- *   MX: 15,
- *   NS: 2,
- *   PTR: 12,
- *   SOA: 6,
- *   SPF: 99,
- *   SRV: 33,
- *   TXT: 16,
- * } as const);
- *
- * // DnsRecordType is now a readonly object:
- * // {
- * //   readonly A: 1;
- * //   readonly AAAA: 28;
- * //   readonly CAA: 257;
- * //   readonly CNAME: 5;
- * //   readonly DNAME: 39;
- * //   readonly MX: 15;
- * //   readonly NS: 2;
- * //   readonly PTR: 12;
- * //   readonly SOA: 6;
- * //   readonly SPF: 99;
- * //   readonly SRV: 33;
- * //   readonly TXT: 16;
- * // }
- * ```
- */
-export declare const Enum: <const T extends Record<string | number | symbol, unknown>>(obj: Readonly<T>) => Enum<T>;
-/**
- * A utility type that, given a `Record<string, unknown>`, returns a readonly version
- * of that record. This results in a type where all properties of `T` are readonly.
- *
- * @template T - The record type to make readonly.
- *
- * @example
- * ```typescript
- * // Given a record:
- * export const DnsRecordType = Enum({
- *   A: 1,
- *   AAAA: 28,
- *   CAA: 257,
- *   CNAME: 5,
- *   DNAME: 39,
- *   MX: 15,
- *   NS: 2,
- *   PTR: 12,
- *   SOA: 6,
- *   SPF: 99,
- *   SRV: 33,
- *   TXT: 16,
- * })
- *
- * // Now the type inference will preserve the literal types:
- * export type DnsRecordType = Enum<typeof DnsRecordType>
- * ```
- */
-export type Enum<T extends Readonly<Record<string | number | symbol, unknown>>> = {
-    readonly [K in keyof T]: T[K];
-};
-/**
- * A utility type that, given an `Enum` object, returns the union of its values.
- */
-export type EnumValue<T extends Record<string | number | symbol, unknown>, K = Enum<T>> = K[keyof K];
-//# sourceMappingURL=Enum.d.ts.map
+/**
+ * Transforms a given record object into a readonly "enum-like" structure while preserving
+ * the literal types of its values. This allows you to use the returned object both at runtime
+ * (for lookups) and at compile time (for strongly typed values).
+ *
+ * To maintain literal types (i.e., prevent them from being widened to `string`, `number`, etc.),
+ * ensure you annotate your object with `as const` before passing it to `Enum`.
+ *
+ * @template T - A record type with string keys and any kind of values.
+ * @param obj - A readonly record object annotated with `as const`.
+ * @returns A readonly version of the provided record, preserving exact literal value types.
+ *
+ * @example
+ * ```typescript
+ * // Defining a record with literal types using as const:
+ * const DnsRecordType = Enum({
+ *   A: 1,
+ *   AAAA: 28,
+ *   CAA: 257,
+ *   CNAME: 5,
+ *   DNAME: 39,
+ *   MX: 15,
+ *   NS: 2,
+ *   PTR: 12,
+ *   SOA: 6,
+ *   SPF: 99,
+ *   SRV: 33,
+ *   TXT: 16,
+ * } as const);
+ *
+ * // DnsRecordType is now a readonly object:
+ * // {
+ * //   readonly A: 1;
+ * //   readonly AAAA: 28;
+ * //   readonly CAA: 257;
+ * //   readonly CNAME: 5;
+ * //   readonly DNAME: 39;
+ * //   readonly MX: 15;
+ * //   readonly NS: 2;
+ * //   readonly PTR: 12;
+ * //   readonly SOA: 6;
+ * //   readonly SPF: 99;
+ * //   readonly SRV: 33;
+ * //   readonly TXT: 16;
+ * // }
+ * ```
+ */
+export declare const Enum: <const T extends Record<string | number | symbol, unknown>>(obj: Readonly<T>) => Enum<T>;
+
+/**
+ * A utility type that, given a `Record<string, unknown>`, returns a readonly version
+ * of that record. This results in a type where all properties of `T` are readonly.
+ *
+ * @template T - The record type to make readonly.
+ *
+ * @example
+ * ```typescript
+ * // Given a record:
+ * export const DnsRecordType = Enum({
+ *   A: 1,
+ *   AAAA: 28,
+ *   CAA: 257,
+ *   CNAME: 5,
+ *   DNAME: 39,
+ *   MX: 15,
+ *   NS: 2,
+ *   PTR: 12,
+ *   SOA: 6,
+ *   SPF: 99,
+ *   SRV: 33,
+ *   TXT: 16,
+ * })
+ *
+ * // Now the type inference will preserve the literal types:
+ * export type DnsRecordType = Enum<typeof DnsRecordType>
+ * ```
+ */
+export declare type Enum<T extends Readonly<Record<string | number | symbol, unknown>>> = {
+    readonly [K in keyof T]: T[K];
+};
+
+/**
+ * A utility type that, given an `Enum` object, returns the union of its values.
+ */
+export declare type EnumValue<T extends Record<string | number | symbol, unknown>, K = Enum<T>> = K[keyof K];
+
+export { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/enum",
-  "version": "4.12.44",
+  "version": "4.13.1",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -21,16 +21,16 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
+      "types": "./dist/neutral/index.d.ts",
       "default": "./dist/neutral/index.mjs"
     },
     "./package.json": "./package.json"
   },
   "module": "dist/neutral/index.mjs",
-  "types": "dist/types/index.d.ts",
+  "types": "dist/neutral/index.d.ts",
   "devDependencies": {
-    "@xylabs/ts-scripts-yarn3": "^6.5.12",
-    "@xylabs/tsconfig": "^6.5.12",
+    "@xylabs/ts-scripts-yarn3": "^7.0.0-rc.7",
+    "@xylabs/tsconfig": "^7.0.0-rc.7",
     "typescript": "^5.8.3"
   },
   "publishConfig": {

package/dist/types/Enum.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Enum.d.ts","sourceRoot":"","sources":["../../src/Enum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAG,IAAI,CAAC,CAAC,CAExG,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI;IAChF,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC9B,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA"}

package/dist/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from './Enum.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA"}