@tolki/enum 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Abraham Arango
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,189 @@
+# Tolki JS Enum Package
+
+This package provides enum utility functions similar to Laravel's Enum class facade.
+
+## Documentation
+
+The full documentation for the enum utilities can be found at [https://tolki.abe.dev](https://tolki.abe.dev/enums/).
+
+<!-- AUTO-GENERATED-DOCS:START -->
+
+# Enum Utilities Installation
+
+The [`@tolki/enum`](https://www.npmjs.com/package/@tolki/enum) package provides a variety of enum manipulation utilities inspired by PHP's enum utilities like [from](https://www.php.net/manual/en/backedenum.from.php), [tryFrom](https://www.php.net/manual/en/backedenum.tryfrom.php), and [cases](https://www.php.net/manual/en/unitenum.cases.php).
+
+This package is meant to be used with the Laravel enum package [Laravel TypeScript Publisher](https://github.com/abetwothree/laravel-ts-publish), which transforms PHP enums into TypeScript enums. The `@tolki/enum` package provides utilities to work with these TypeScript enums in a way that is similar to how you would work with PHP enums in Laravel.
+
+You can install this package via npm, yarn, or pnpm:
+
+```bash [npm]
+npm install @tolki/enum
+```
+
+```bash [yarn]
+yarn add @tolki/enum
+```
+
+```bash [pnpm]
+pnpm add @tolki/enum
+```
+
+# Tolki Enum Utilities List
+
+## Enum Utilities List
+
+As mentioned in the [Enum Utilities Installation](./index.md) page, the `@tolki/enum` package is not meant to be used as standalone package as it works with the [Laravel TypeScript Publisher](https://github.com/abetwothree/laravel-ts-publish) package to transform PHP enums into TypeScript enums. The functions below are being listed out for reference, not necessarily for direct use.
+
+[cases](#cases) [defineEnum](#defineenum) [from](#from) [tryFrom](#tryfrom)
+
+## Enum Utilities Details
+
+### cases
+
+Similar to the PHP [cases](https://www.php.net/manual/en/unitenum.cases.php) method, this function returns an array of all the cases of the given enum.
+
+```javascript
+import { cases } from "@tolki/enum";
+import { Status } from "@js/types/enums";
+
+const result = cases(Status); // result is an array with an enum instance for each case in the Status enum
+```
+
+### defineEnum
+
+This is a factory function that is automatically applied by the Laravel TypeScript Publisher package when it transforms PHP enums into TypeScript enums. It automatically adds the `cases`, `from`, and `tryFrom` methods to the transformed TypeScript enums.
+
+```javascript
+import { defineEnum } from "@tolki/enum";
+
+const Status = defineEnum({
+  ACTIVE: "active",
+  INACTIVE: "inactive",
+  PENDING: "pending",
+  // automatically added by the Laravel TypeScript Publisher package
+  _cases: ["ACTIVE", "INACTIVE", "PENDING"],
+  _methods: [],
+  _static: [],
+});
+
+Status.cases(); // result is an array with an enum instance for each case in the Status enum
+Status.from("active"); // result is the enum instance for the ACTIVE case
+Status.tryFrom("non-valid-key"); // result null
+```
+
+### from
+
+Similar to the PHP [from](https://www.php.net/manual/en/backedenum.from.php) method, this function returns the enum instance for the given value. If the value does not exist in the enum, it throws an error.
+
+```javascript
+import { from } from "@tolki/enum";
+import { Status } from "@js/types/enums";
+
+const result = from(Status, "active"); // result is the enum instance for the ACTIVE case
+const result2 = from(Status, "non-valid-key"); // throws an error because "non-valid-key" is not a valid value
+```
+
+### tryFrom
+
+Similar to the PHP [tryFrom](https://www.php.net/manual/en/backedenum.tryfrom.php) method, this function returns the enum instance for the given value. If the value does not exist in the enum, it returns null instead of throwing an error.
+
+```javascript
+import { tryFrom } from "@tolki/enum";
+import { Status } from "@js/types/enums";
+
+const result = tryFrom(Status, "active"); // result is the enum instance for the ACTIVE case
+const result2 = tryFrom(Status, "non-valid-key"); // result is null because "non-valid-key" is not a valid value
+```
+
+# Tolki Enum Laravel TypeScript Publisher Vite Plugin
+
+The `@tolki/enum` package provides a Vite plugin to automatically watch for changes of the transformed PHP files by the [Laravel TypeScript Publisher](https://github.com/abetwothree/laravel-ts-publish) package.
+
+The Laravel TypeScript Publisher package can publish a JSON file list of transformed PHP files. This Vite plugin uses that JSON file list to watch for changes in those PHP files and automatically call the `php artisan ts:publish` command to transform the changed PHP files into TypeScript files.
+
+## Usage
+
+To use the Vite plugin, you need to add it to your Vite configuration file. Below is an example of how to add the plugin to your Vite configuration file:
+
+```javascript
+import { defineConfig } from "vite";
+import { laravelTsPublish } from "@tolki/enum";
+
+export default defineConfig({
+  plugins: [laravelTsPublish()],
+});
+```
+
+## Default Functionality
+
+By default, the plugin will work in the following way:
+
+1. It will call `php artisan ts:publish` as the republish command when a file changes.
+2. It will look for the list of transformed PHP files here: `resources/js/types/laravel-ts-collected-files.json`.
+3. It will reload the page after you make any update to any of the transformed PHP files.
+4. It will call the publish command on `vite build` before bundling.
+5. It will throw an error if the publish command fails on `vite build`.
+
+## Plugin Options
+
+The plugin accepts an options object to customize its behavior. It is recommended to use `.env` config settings to sync settings between the PHP side and the Vite plugin for the `filename` and `directory` options.
+
+Below are the available options with a description and default values:
+
+```javascript
+import { defineConfig } from "vite";
+import { laravelTsPublish } from "@tolki/enum";
+
+export default defineConfig({
+  plugins: [
+    laravelTsPublish({
+      /**
+       * The publish command to run when a watched PHP file changes.
+       *
+       * If you use Sail and run your Vite dev server inside the Sail container,
+       * you may need to change this command to `sail php artisan ts:publish`
+       * or `./vendor/bin/sail php artisan ts:publish` depending on your setup.
+       */
+      command: "php artisan ts:publish",
+      /**
+       * The filename of the JSON manifest listing collected PHP files.
+       */
+      filename: "laravel-ts-collected-files.json",
+      /**
+       * The directory where the JSON manifest file exists, relative to the Vite root.
+       */
+      directory: "resources/js/types/",
+      /**
+       * Whether to run the publish command once when `vite dev` starts.
+       *
+       * Has no effect during `vite build`.
+       */
+      runOnDevStart: false,
+      /**
+       * Whether to run the publish command once before bundling during `vite build`.
+       *
+       * Has no effect during `vite dev`.
+       */
+      runOnBuildStart: true,
+      /**
+       * Whether to trigger a full browser reload after the
+       * command runs successfully during `vite dev`.
+       *
+       * Has no effect during `vite build`.
+       */
+      reload: true,
+      /**
+       * Whether to throw an error (aborting the build) when the command fails.
+       *
+       * When not specified, defaults to `true` during `vite build`
+       * and `false` during `vite dev`.
+       *
+       * When specified, it will apply to both `vite dev` and `vite build`.
+       */
+      failOnError: undefined,
+    }),
+  ],
+});
+```
+
+<!-- AUTO-GENERATED-DOCS:END -->

package/dist/enums.d.ts

@@ -0,0 +1,51 @@
+import { CaseValue, DefineEnumResult, EnumConst, ToEnumResult } from '../../types/src/index.ts';
+/**
+ * Creates an enum instance from a case value similar to PHP's `BackedEnum::from()`
+ *
+ * It will remove all the cases and make the matching case's value available as `value`
+ *
+ * All instance methods will be flattened from an object of case keys & values to a key/value pair for the matched case.
+ *
+ * The enumObj is the published enum from the Laravel TypeScript Publish package.
+ *
+ * @see https://github.com/abetwothree/laravel-ts-publish#enum-metadata--tolki-enum-package
+ *
+ * @param enumObj - The enum const object to resolve from.
+ * @param value - The case value to resolve. Must be one of the values defined in the enum const's cases.
+ * @returns The resolved enum case with its associated methods and properties for the value provided.
+ * @throws If the value does not match any case in the enum, an error is thrown.
+ */
+export declare function from<TEnum extends EnumConst, const TValue extends CaseValue<TEnum>>(enumObj: TEnum, value: TValue): ToEnumResult<TEnum, TValue>;
+/**
+ * Similar to the {@linkcode from | from} function but returns null instead of throwing an error for invalid values.
+ *
+ * Mirrors PHP's `BackedEnum::tryFrom()`.
+ *
+ * @param enumObj - The enum const object to resolve from.
+ * @param value - The case value to resolve.
+ * @returns The resolved enum case, or null if the value does not match any case.
+ */
+export declare function tryFrom<TEnum extends EnumConst, const TValue extends CaseValue<TEnum>>(enumObj: TEnum, value: TValue): ToEnumResult<TEnum, TValue> | null;
+/**
+ * Returns all enum cases as resolved instances by running each case value through the {@linkcode from | from} function.
+ *
+ * Mirrors PHP's `BackedEnum::cases()`, returning one resolved instance per case defined in the enum const.
+ *
+ * @param enumObj - The enum const object to resolve all cases from.
+ * @returns An array of resolved enum instances, one for each case.
+ */
+export declare function cases<TEnum extends EnumConst>(enumObj: TEnum): Array<ToEnumResult<TEnum, CaseValue<TEnum>>>;
+/**
+ * Factory function that creates an enriched enum object
+ *
+ * It automatically binds Tolki helper methods {@linkcode from | from}, {@linkcode tryFrom | tryFrom}, and {@linkcode cases | cases}.
+ *
+ * This allows your published enum to have PHP-like enum behavior with type safety and autocompletion in TypeScript.
+ *
+ * The original enum data is preserved and the PHP like enum methods are attached directly to the returned object.
+ *
+ * @param enumObj - The raw enum const object to enrich.
+ * @returns The enum object with `from`, `tryFrom`, and `cases` methods bound to it.
+ */
+export declare function defineEnum<const TEnum extends EnumConst>(enumObj: TEnum): DefineEnumResult<TEnum>;
+//# sourceMappingURL=enums.d.ts.map

package/dist/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../src/enums.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,SAAS,EACT,gBAAgB,EAChB,SAAS,EACT,YAAY,EACf,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAChB,KAAK,SAAS,SAAS,EACvB,KAAK,CAAC,MAAM,SAAS,SAAS,CAAC,KAAK,CAAC,EACvC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,CA2C5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CACnB,KAAK,SAAS,SAAS,EACvB,KAAK,CAAC,MAAM,SAAS,SAAS,CAAC,KAAK,CAAC,EACvC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,IAAI,CAMnE;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,SAAS,SAAS,EACzC,OAAO,EAAE,KAAK,GACf,KAAK,CAAC,YAAY,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAI9C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,KAAK,CAAC,KAAK,SAAS,SAAS,EACpD,OAAO,EAAE,KAAK,GACf,gBAAgB,CAAC,KAAK,CAAC,CA2BzB"}

package/dist/enums.js

@@ -0,0 +1,57 @@
+function c(e, t) {
+  const n = new Set(e._cases);
+  let r;
+  for (const s of n)
+    if (e[s] === t) {
+      r = s;
+      break;
+    }
+  if (!r)
+    throw new Error(
+      `Value "${String(t)}" does not match any case in the enum. Cases: ${[...n].join(", ")}`
+    );
+  const o = { value: t }, h = new Set(e._methods), a = e._helpers, f = new Set(
+    Array.isArray(a) ? a : []
+  ), l = /* @__PURE__ */ new Set([
+    "_cases",
+    "_methods",
+    "_helpers",
+    "_static"
+  ]);
+  for (const [s, i] of Object.entries(e))
+    l.has(s) || n.has(s) || f.has(s) || (h.has(s) ? o[s] = i[r] : o[s] = i);
+  return o;
+}
+function y(e, t) {
+  try {
+    return c(e, t);
+  } catch {
+    return null;
+  }
+}
+function _(e) {
+  return e._cases.map(
+    (t) => c(e, e[t])
+  );
+}
+function p(e) {
+  const t = {
+    from: (r) => c(e, r),
+    tryFrom: (r) => y(e, r),
+    cases: () => _(e)
+  }, n = Object.keys(t);
+  return Object.assign(
+    /* @__PURE__ */ Object.create(null),
+    e,
+    t,
+    {
+      _helpers: n
+    }
+  );
+}
+export {
+  _ as cases,
+  p as defineEnum,
+  c as from,
+  y as tryFrom
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './enums';
+export * from './vite-plugin';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+import { cases as o, defineEnum as m, from as f, tryFrom as s } from "./enums.js";
+import { laravelTsPublish as l } from "./vite-plugin.js";
+export {
+  o as cases,
+  m as defineEnum,
+  f as from,
+  l as laravelTsPublish,
+  s as tryFrom
+};

package/dist/vite-plugin.d.ts

@@ -0,0 +1,101 @@
+import { Plugin } from 'vite';
+export interface LaravelTsPublishOptions {
+    /**
+     * The command to run when a watched PHP file changes.
+     *
+     * @default "php artisan ts:publish"
+     */
+    command?: string;
+    /**
+     * The filename of the JSON manifest listing collected PHP files.
+     *
+     * @default "laravel-ts-collected-files.json"
+     */
+    filename?: string;
+    /**
+     * The directory where the JSON manifest file exists, relative to the Vite root.
+     *
+     * @default "resources/js/types/"
+     */
+    directory?: string;
+    /**
+     * Whether to run the publish command once when `vite dev` starts.
+     *
+     * Has no effect during `vite build`.
+     *
+     * @default false
+     */
+    runOnDevStart?: boolean;
+    /**
+     * Whether to run the publish command once before bundling during
+     * `vite build`.
+     *
+     * Has no effect during `vite dev`.
+     *
+     * @default true
+     */
+    runOnBuildStart?: boolean;
+    /**
+     * Whether to trigger a full browser reload after the command runs
+     * successfully during `vite dev`.
+     *
+     * Has no effect during `vite build`.
+     *
+     * @default true
+     */
+    reload?: boolean;
+    /**
+     * Whether to throw an error (aborting the build) when the command fails.
+     *
+     * When not specified, defaults to `true` during `vite build` and `false`
+     * during `vite dev`.
+     */
+    failOnError?: boolean;
+}
+/**
+ * Vite plugin that watches PHP source files listed in the Laravel TypeScript
+ * Publisher manifest and re-runs the publish command when any of them change.
+ *
+ * - **Build mode** (`vite build`): runs the command once before bundling so
+ *   TypeScript definitions are always up-to-date (disable with
+ *   `runOnBuildStart: false`). Fails the build by default if the command errors.
+ * - **Dev mode** (`vite dev`): loads the manifest, explicitly adds the listed
+ *   PHP files to the dev-server file watcher, and re-runs the command when any
+ *   of them change via HMR. Optionally runs the command once at startup when
+ *   `runOnDevStart` is `true`. Sends a full browser reload after every
+ *   successful run (disable with `reload: false`).
+ *
+ * @param options - Configuration options for the plugin.
+ * @returns A Vite plugin object.
+ *
+ * @example
+ * ```ts
+ * // vite.config.ts
+ * import { defineConfig } from "vite";
+ * import { laravelTsPublish } from "@tolki/enum";
+ *
+ * export default defineConfig({
+ *     plugins: [
+ *         laravelTsPublish(),
+ *     ],
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With Laravel Sail
+ * laravelTsPublish({
+ *     command: "sail artisan ts:publish",
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Also run the command when the dev server starts
+ * laravelTsPublish({
+ *     runOnDevStart: true,
+ * });
+ * ```
+ */
+export declare function laravelTsPublish(options?: LaravelTsPublishOptions): Plugin;
+//# sourceMappingURL=vite-plugin.d.ts.map

package/dist/vite-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin.d.ts","sourceRoot":"","sources":["../src/vite-plugin.ts"],"names":[],"mappings":"AAKA,OAAO,EAEH,KAAK,MAAM,EAGd,MAAM,MAAM,CAAC;AAId,MAAM,WAAW,uBAAuB;IACpC;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,gBAAgB,CAC5B,OAAO,GAAE,uBAA4B,GACtC,MAAM,CA8LR"}

package/dist/vite-plugin.js

@@ -0,0 +1,99 @@
+import { exec as O } from "node:child_process";
+import { readFile as z } from "node:fs/promises";
+import p from "node:path";
+import { promisify as P } from "node:util";
+import { normalizePath as c } from "vite";
+const T = P(O);
+function C(h = {}) {
+  const {
+    command: u = "php artisan ts:publish",
+    filename: w = "laravel-ts-collected-files.json",
+    directory: y = "resources/js/types/",
+    runOnDevStart: v = !1,
+    runOnBuildStart: $ = !0,
+    reload: b = !0,
+    failOnError: d
+  } = h;
+  let r, i;
+  const t = /* @__PURE__ */ new Set();
+  let s = "", l = !1, f = !1;
+  const a = "[laravel-ts-publish]", m = async () => {
+    t.clear();
+    try {
+      const e = await z(s, "utf-8"), o = JSON.parse(e);
+      for (const S of o) {
+        const F = c(p.resolve(r.root, S));
+        t.add(F);
+      }
+    } catch (e) {
+      if (e instanceof Error && e.code === "ENOENT") {
+        r.logger.warn(
+          `${a} Manifest not found: ${s}`
+        );
+        return;
+      }
+      r.logger.error(
+        `${a} Failed to read manifest: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+  }, g = () => {
+    if (i)
+      for (const e of t)
+        i.watcher.add(e);
+  }, E = () => d !== void 0 ? d : r.command === "build", n = async () => {
+    if (l) {
+      f = !0;
+      return;
+    }
+    l = !0;
+    try {
+      r.logger.info(`${a} Running: ${u}`, {
+        timestamp: !0
+      }), await T(u, { cwd: r.root }), r.logger.info(`${a} Types published successfully`, {
+        timestamp: !0
+      }), b && i && i.ws.send({ type: "full-reload" });
+    } catch (e) {
+      const o = `${a} Command failed: ${e instanceof Error ? e.message : String(e)}`;
+      if (E())
+        throw new Error(o, { cause: e });
+      r.logger.error(o);
+    } finally {
+      l = !1, f && (f = !1, await n());
+    }
+  };
+  return {
+    name: "@tolki/vite-plugin-laravel-ts-publish",
+    enforce: "pre",
+    configResolved(e) {
+      r = e, s = c(
+        p.resolve(r.root, y, w)
+      );
+    },
+    configureServer(e) {
+      i = e;
+    },
+    async buildStart() {
+      if (r.command === "build") {
+        $ && await n();
+        return;
+      }
+      await m(), g(), t.size > 0 && r.logger.info(
+        `${a} Watching ${t.size} PHP file${t.size === 1 ? "" : "s"} for changes`,
+        { timestamp: !0 }
+      ), v && await n();
+    },
+    async handleHotUpdate({ file: e }) {
+      const o = c(e);
+      if (o === s)
+        return r.logger.info(
+          `${a} Manifest changed, reloading watched files`,
+          { timestamp: !0 }
+        ), await m(), g(), await n(), [];
+      if (t.has(o))
+        return await n(), [];
+    }
+  };
+}
+export {
+  C as laravelTsPublish
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@tolki/enum",
+  "version": "0.0.0",
+  "description": "A set of enum utilities for the @tolki packages.",
+  "author": "Abraham Arango <https://github.com/abetwothree>",
+  "license": "MIT",
+  "homepage": "https://tolki.abe.dev/enums/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abetwothree/tolki.git",
+    "directory": "packages/enum"
+  },
+  "bugs": {
+    "url": "https://github.com/abetwothree/tolki/issues"
+  },
+  "main": "dist/index.js",
+  "type": "module",
+  "keywords": [
+    "enum",
+    "enums",
+    "laravel",
+    "utils",
+    "utilities"
+  ],
+  "dependencies": {
+    "@tolki/types": "^1.1.0"
+  },
+  "peerDependencies": {
+    "vite": "^7.0.0"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "tolki": {
+    "docs": [
+      "enums/index.md",
+      "enums/enum-utilities-list.md",
+      "enums/enum-vite-plugin.md"
+    ]
+  },
+  "scripts": {
+    "build": "vite build",
+    "readme:build": "ts-node ../../scripts/readme-build.ts --filter @tolki/enum"
+  },
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./enums": {
+      "import": "./dist/enums/index.js",
+      "types": "./dist/enums/index.d.ts"
+    },
+    "./vite": {
+      "import": "./dist/vite-plugin/index.js",
+      "types": "./dist/vite-plugin/index.d.ts"
+    }
+  }
+}