nuxt-loaders 1.0.0

package/README.md

@@ -0,0 +1,84 @@
+<!--
+Get your module up and running quickly.
+
+Find and replace all on all files (CMD+SHIFT+F):
+- Name: My Module
+- Package name: my-module
+- Description: My new Nuxt module
+-->
+
+# My Module
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+My new Nuxt module for doing amazing things.
+
+- [✨ &nbsp;Release Notes](/CHANGELOG.md)
+<!-- - [🏀 Online playground](https://stackblitz.com/github/your-org/my-module?file=playground%2Fapp.vue) -->
+<!-- - [📖 &nbsp;Documentation](https://example.com) -->
+
+## Features
+
+<!-- Highlight some of the features your module provide here -->
+- ⛰ &nbsp;Foo
+- 🚠 &nbsp;Bar
+- 🌲 &nbsp;Baz
+
+## Quick Setup
+
+Install the module to your Nuxt application with one command:
+
+```bash
+npx nuxi module add my-module
+```
+
+That's it! You can now use My Module in your Nuxt app ✨
+
+
+## Contribution
+
+<details>
+  <summary>Local development</summary>
+  
+  ```bash
+  # Install dependencies
+  npm install
+  
+  # Generate type stubs
+  npm run dev:prepare
+  
+  # Develop with the playground
+  npm run dev
+  
+  # Build the playground
+  npm run dev:build
+  
+  # Run ESLint
+  npm run lint
+  
+  # Run Vitest
+  npm run test
+  npm run test:watch
+  
+  # Release new version
+  npm run release
+  ```
+
+</details>
+
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/my-module/latest.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-version-href]: https://npmjs.com/package/my-module
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/my-module.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-downloads-href]: https://npm.chart.dev/my-module
+
+[license-src]: https://img.shields.io/npm/l/my-module.svg?style=flat&colorA=020420&colorB=00DC82
+[license-href]: https://npmjs.com/package/my-module
+
+[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt.js
+[nuxt-href]: https://nuxt.com

package/dist/bin/loaders.d.mts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/bin/loaders.mjs

@@ -0,0 +1,218 @@
+import { readFile, writeFile, readdir } from 'node:fs/promises';
+import { existsSync, mkdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+
+const PREFIX = "[nuxt-loaders-cli]";
+const logWarnCli = (...log) => {
+  console.warn(`${PREFIX}:warn`, ...log);
+};
+const logErrorCli = (...log) => {
+  console.error(`${PREFIX}:error`, ...log);
+};
+const logInfoCli = (...log) => {
+  console.log(`${PREFIX}:info`, ...log);
+};
+
+function omitKey(obj, key) {
+  const { [key]: _, ...rest } = obj;
+  return rest;
+}
+
+const ALLOWED_OPERATIONS = ["add", "remove"];
+const REMOTE_TEMPLATE_STORE = "https://raw.githubusercontent.com/haileabt/nuxt-loaders/main/src/templates";
+const operationAllowed = (operation) => {
+  if (!ALLOWED_OPERATIONS.includes(operation)) {
+    logErrorCli(`Invalid operation: ${operation}`);
+    return false;
+  }
+  return true;
+};
+const getLoadersConfig = async () => {
+  const path = join(process.cwd(), "loaders.config.json");
+  if (!existsSync(path)) {
+    logErrorCli(`No loaders.config.json found at ${path}`);
+    return null;
+  }
+  const config = await readFile(path, "utf-8");
+  return JSON.parse(config);
+};
+const addLoaderToConfig = async (slug, loaderName, version) => {
+  const path = join(process.cwd(), "loaders.config.json");
+  if (!existsSync(path)) {
+    logErrorCli(`No loaders.config.json found at ${path}`);
+    return null;
+  }
+  const configFile = await readFile(path, "utf-8");
+  const config = JSON.parse(configFile);
+  const newInstalledLoaders = {
+    ...config.installedLoaders,
+    [slug]: {
+      file: loaderName,
+      version
+    }
+  };
+  const newConfig = {
+    ...config,
+    installedLoaders: { ...newInstalledLoaders }
+  };
+  const newConfigFile = JSON.stringify(newConfig);
+  await writeFile(path, newConfigFile);
+};
+const removeLoaderFromConfig = async (slug) => {
+  const path = join(process.cwd(), "loaders.config.json");
+  if (!existsSync(path)) {
+    logErrorCli(`No loaders.config.json found at ${path}`);
+    return null;
+  }
+  const configFile = await readFile(path, "utf-8");
+  const config = JSON.parse(configFile);
+  config.installedLoaders = omitKey(config.installedLoaders, slug);
+  const newConfigFile = JSON.stringify(config);
+  await writeFile(path, newConfigFile);
+  return;
+};
+const getRemoteLoader = async (slug, index) => {
+  const loader = index[slug];
+  if (!loader) {
+    logErrorCli(`No loader found for slug: ${slug}`);
+    return null;
+  }
+  const res = await fetch(`${REMOTE_TEMPLATE_STORE}/${loader.file}`);
+  if (!res.ok) {
+    logErrorCli(`Failed to read remote loader: ${slug}`);
+    return null;
+  }
+  return res.text();
+};
+const getTemplatesIndex = async () => {
+  const res = await fetch(`${REMOTE_TEMPLATE_STORE}/index.json`);
+  if (!res.ok) {
+    logErrorCli(`Failed to read remote loader index`);
+    return null;
+  }
+  const indexJson = await res.text();
+  return JSON.parse(indexJson);
+};
+const handleAddLoader = async (slug, loadersConfig, index) => {
+  logInfoCli(`Adding loader: ${slug}...`);
+  let configSync = true;
+  if (!index[slug]) {
+    logErrorCli(`No loader found for slug: ${slug}`);
+    return;
+  }
+  const loadersPath = join(process.cwd(), loadersConfig.loadersDir);
+  if (!existsSync(loadersPath)) {
+    mkdirSync(loadersPath);
+    logInfoCli(`Created loaders directory at ${loadersPath}`);
+  }
+  const loader = loadersConfig.installedLoaders[slug];
+  if (loader) {
+    if (existsSync(`${loadersPath}/${loader.file}`)) {
+      logErrorCli(`Loader already installed: ${slug}`);
+      return;
+    }
+    configSync = false;
+  }
+  const remoteLoader = await getRemoteLoader(slug, index);
+  if (!remoteLoader) {
+    logErrorCli("Error finding loader", slug);
+    return;
+  }
+  const loaderPath = join(loadersPath, index[slug].file);
+  if (!configSync && loader) {
+    await addLoaderToConfig(slug, index[slug].file, index[slug].version);
+    logInfoCli(`Updated config for loader: ${slug}`);
+  } else if (!loader) {
+    await addLoaderToConfig(slug, index[slug].file, index[slug].version);
+    logInfoCli(`Updated config for loader: ${slug}`);
+  }
+  await writeFile(loaderPath, remoteLoader);
+  logInfoCli(`Successfully added loader: ${slug}`);
+};
+const handleRemoveLoader = async (slug, loadersConfig, index) => {
+  logInfoCli(`Removing loader: ${slug}...`);
+  const loadersPath = join(process.cwd(), loadersConfig.loadersDir);
+  if (!existsSync(loadersPath)) {
+    logWarnCli(
+      `Loaders path '${loadersPath}' not found. Skipping loader deletion.`
+    );
+  }
+  const loader = loadersConfig.installedLoaders[slug];
+  if (!loader) {
+    if (existsSync(`${loadersPath}/${index[slug]?.file}`)) ; else {
+      logWarnCli(`Loader '${slug}' not found in config or file system.`);
+      return;
+    }
+  }
+  if (loader && existsSync(`${loadersPath}/${loader.file}`)) {
+    await removeLoaderFromConfig(slug);
+    logInfoCli(`Removed loader '${slug}' from config.`);
+    unlinkSync(`${loadersPath}/${loader.file}`);
+    logInfoCli(`Deleted loader file: ${loader.file}`);
+  } else {
+    await removeLoaderFromConfig(slug);
+    logInfoCli(`Removed loader '${slug}' from config.`);
+  }
+  logInfoCli(`Successfully removed loader: ${slug}`);
+};
+
+const dir = await readdir(process.cwd());
+if (!dir.includes("nuxt.config.ts") && !dir.includes("nuxt.config.js")) {
+  logErrorCli(
+    "Not a Nuxt project. Please run this command in the root directory of your Nuxt project."
+  );
+  process.exit(1);
+}
+if (process.argv.length < 3) {
+  logErrorCli(
+    'No operation specified. Please use "nuxt-loaders add <loader>" or "nuxt-loaders remove <loader>"'
+  );
+  process.exit(1);
+}
+const args = process.argv.slice(2);
+if (args.length < 1) {
+  logErrorCli(
+    'No loader specified. Please use "nuxt-loaders add <loader>" or "nuxt-loaders remove <loader>"'
+  );
+  process.exit(1);
+}
+const operation = args[0];
+if (!operationAllowed(operation || "")) {
+  logErrorCli("Invalid operation: " + operation, "User 'add' or 'remove'");
+  process.exit(1);
+}
+const loaders = args.slice(1);
+if (loaders.length < 1) {
+  logErrorCli(
+    'No loader specified. Please use "nuxt-loaders add <loader>" or "nuxt-loaders remove <loader>"'
+  );
+  process.exit(1);
+}
+logInfoCli(`Starting nuxt-loaders CLI...`);
+const loadersConfig = await getLoadersConfig();
+if (!loadersConfig) {
+  logErrorCli("Could not find loaders config. Please initialize the module.");
+  process.exit(1);
+}
+const templatesIndex = await getTemplatesIndex();
+if (!templatesIndex) {
+  logErrorCli(
+    "Could not find any loader templates. Please stay tuned for some."
+  );
+  process.exit(1);
+}
+for (const loader of loaders) {
+  if (!templatesIndex[loader]) {
+    logErrorCli(`No loader found for slug: ${loader}`);
+    process.exit(1);
+  }
+  if (operation === "add") {
+    await handleAddLoader(loader, loadersConfig, templatesIndex);
+  } else if (operation === "remove") {
+    await handleRemoveLoader(loader, loadersConfig, templatesIndex);
+  } else {
+    logErrorCli(`Invalid operation: ${operation}`);
+    process.exit(1);
+  }
+}
+logInfoCli(`Operation ${operation} completed successfully.`);

package/dist/module.d.mts

@@ -0,0 +1,13 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface ModuleOptions {
+    autoSetup: boolean;
+    loadersDir?: string;
+    routeRules: Record<string, string>;
+    _activeLoader: string;
+    _defaultLoader: string;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "nuxt-loaders",
+  "configKey": "loaders",
+  "version": "1.0.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,82 @@
+import { defineNuxtModule, createResolver, addPlugin, addComponentsDir, addImportsDir } from '@nuxt/kit';
+import tailwindcss from '@tailwindcss/vite';
+import { validateLoaderRules, getDefaultLoader } from '../dist/runtime/lib/utils/route-rules.js';
+import { logInfo } from '../dist/runtime/lib/log.js';
+import { existsSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+
+const DEFAULT_LOADERS_PATH = "app/components/loaders";
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "nuxt-loaders",
+    configKey: "loaders"
+  },
+  defaults: {
+    autoSetup: true,
+    routeRules: {},
+    _defaultLoader: "",
+    _activeLoader: ""
+  },
+  async setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.css ??= [];
+    nuxt.options.css.push(resolver.resolve("./runtime/tailwind.css"));
+    const path = await import('node:path');
+    const loadersDirPath = options.loadersDir ? path.resolve(nuxt.options.rootDir, options.loadersDir) : path.resolve(nuxt.options.rootDir, DEFAULT_LOADERS_PATH);
+    const configExists = existsSync("loaders.config.json");
+    if (!configExists) {
+      await writeFile(
+        "loaders.config.json",
+        JSON.stringify({
+          loadersDir: options.loadersDir ?? DEFAULT_LOADERS_PATH,
+          installedLoaders: {}
+        })
+      );
+    }
+    logInfo("Registering loaders directory:", loadersDirPath);
+    const { resolveFiles, addTemplate } = await import('@nuxt/kit');
+    const loaderFiles = await resolveFiles(loadersDirPath, "**/*.vue");
+    const template = addTemplate({
+      filename: "loader-plugin.mjs",
+      getContents: () => {
+        const imports = loaderFiles.map((file, index) => {
+          const name = file.split("/").pop()?.replace(".vue", "") || `Loader${index}`;
+          return `import ${name} from '${file}'`;
+        }).join("\n");
+        const registrations = loaderFiles.map((file, index) => {
+          const name = file.split("/").pop()?.replace(".vue", "") || `Loader${index}`;
+          return `nuxtApp.vueApp.component('${name}', ${name})`;
+        }).join("\n");
+        return `
+import { defineNuxtPlugin } from '#app'
+${imports}
+
+export default defineNuxtPlugin((nuxtApp) => {
+  ${registrations}
+})
+        `;
+      }
+    });
+    addPlugin(template.dst);
+    addComponentsDir({
+      path: resolver.resolve("./runtime/components"),
+      global: true
+    });
+    addImportsDir(resolver.resolve("./runtime/composables"));
+    nuxt.options.vite.plugins ??= [];
+    nuxt.options.vite.plugins.push(tailwindcss());
+    const validatedLoaderRules = validateLoaderRules(options.routeRules);
+    nuxt.options.runtimeConfig.public.loaders = {
+      ...options,
+      routeRules: validatedLoaderRules,
+      loadersDir: loadersDirPath
+    };
+    if (options.routeRules && Object.keys(options.routeRules).length > 0) {
+      nuxt.options.runtimeConfig.public.loaders._activeLoader = getDefaultLoader(validatedLoaderRules) ?? "";
+    }
+    nuxt.options.runtimeConfig.public.loaders._defaultLoader = getDefaultLoader(validatedLoaderRules) ?? "";
+    addPlugin(resolver.resolve("./runtime/plugin"));
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/components/Loader.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/Loader.vue

@@ -0,0 +1,20 @@
+<template>
+  <div>
+    <component :is="loaderName" v-if="loaderName" />
+  </div>
+</template>
+
+<script setup>
+import { useNuxtApp } from "#app";
+import { computed } from "vue";
+import { logWarn } from "../lib/log";
+const nuxt = useNuxtApp();
+const loaderName = computed(() => {
+  const name = nuxt.$config.public.loaders._activeLoader || nuxt.$config.public.loaders._defaultLoader;
+  if (!name || !name.trim()) {
+    logWarn("No loaders have been set.");
+    return null;
+  }
+  return name;
+});
+</script>

package/dist/runtime/components/Loader.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/composables/useLoader.d.ts

@@ -0,0 +1,3 @@
+export declare const useLoader: () => {
+    isLoading: import("vue").Ref<boolean, boolean>;
+};

package/dist/runtime/composables/useLoader.js

@@ -0,0 +1,5 @@
+import { useState } from "#app";
+export const useLoader = () => {
+  const isLoading = useState("nuxt-loaders-loading", () => false);
+  return { isLoading };
+};

package/dist/runtime/lib/log.d.ts

@@ -0,0 +1,3 @@
+export declare const logWarn: (...log: any[]) => void;
+export declare const logError: (...log: any[]) => void;
+export declare const logInfo: (...log: any[]) => void;

package/dist/runtime/lib/log.js

@@ -0,0 +1,10 @@
+const PREFIX = "[nuxt-loaders]";
+export const logWarn = (...log) => {
+  console.warn(`${PREFIX}:warn`, ...log);
+};
+export const logError = (...log) => {
+  console.error(`${PREFIX}:error`, ...log);
+};
+export const logInfo = (...log) => {
+  console.log(`${PREFIX}:info`, ...log);
+};

package/dist/runtime/lib/utils/route-rules.d.ts

@@ -0,0 +1,3 @@
+export declare const validateLoaderRules: (routeRules: Record<string, string>) => Record<string, string>;
+export declare const getDefaultLoader: (routeRules: Record<string, string>) => string | undefined;
+export declare const getActiveLoader: (routeRules: Record<string, string>, path: string) => string | undefined;

package/dist/runtime/lib/utils/route-rules.js

@@ -0,0 +1,91 @@
+import { logInfo, logWarn } from "../log.js";
+const checkLoaderNameValidity = (loaderName) => {
+  const loaderNamePattern = /^[A-Za-z][A-Za-z0-9_-]*$/;
+  if (!loaderNamePattern.test(loaderName)) {
+    return {
+      valid: false,
+      reason: `Loader name '${loaderName}' is invalid. Must start with a letter and contain only alphanumeric characters, hyphens, or underscores.`
+    };
+  }
+  return { valid: true };
+};
+const checkRoutePatternValidity = (route) => {
+  if (route === "*" || route === "/") {
+    return { valid: true };
+  }
+  const routePattern = /^\/[\w\-/]*$/;
+  if (!routePattern.test(route)) {
+    return {
+      valid: false,
+      reason: "Route pattern is invalid. Must start with '/' and contain only alphanumeric characters, hyphens, underscores, or slashes."
+    };
+  }
+  return { valid: true };
+};
+const checkRuleValidity = (route, loaderName) => {
+  const routeValidation = checkRoutePatternValidity(route);
+  if (!routeValidation.valid) {
+    return routeValidation;
+  }
+  return checkLoaderNameValidity(loaderName);
+};
+export const validateLoaderRules = (routeRules) => {
+  const newRules = {};
+  if (!routeRules) return {};
+  Object.keys(routeRules).forEach((route) => {
+    if (!route) return;
+    if (!route.trim()) {
+      logWarn(
+        `Loader rule is invalid. Failed trying to parse '${route}'. Route is empty so it is skipped.`
+      );
+      return;
+    }
+    if (!routeRules[route] || (routeRules[route]?.trim().length || 0) < 1 || routeRules[route] == void 0) {
+      logWarn(
+        `Loader rule is invalid. Failed trying to parse '${route}: ${routeRules[route]}'. Loader name is invalid so it is skipped.`
+      );
+      return;
+    }
+    let normalizedRoute = route;
+    if (route.endsWith("/") && route.length > 1) {
+      normalizedRoute = route.slice(0, -1);
+    }
+    const validResult = checkRuleValidity(normalizedRoute, routeRules[route]);
+    if (!validResult.valid) {
+      logWarn(
+        `Failed to parse rule '${normalizedRoute}'. Reason: ${validResult.reason}. Rule is skipped.`
+      );
+      return;
+    }
+    newRules[normalizedRoute] = routeRules[route];
+    logInfo(`Loaded rule '${normalizedRoute}' -> '${routeRules[route]}'`);
+  });
+  return newRules;
+};
+export const getDefaultLoader = (routeRules) => {
+  const defaultLoader = Object.keys(routeRules).filter((key) => {
+    return key === "*" || key === "/";
+  });
+  if (defaultLoader.length <= 0) {
+    return "";
+  }
+  if (defaultLoader.length > 1) {
+    return routeRules["*"];
+  }
+  return routeRules[defaultLoader[0]];
+};
+export const getActiveLoader = (routeRules, path) => {
+  const rules = Object.keys(routeRules).filter((rule2) => {
+    if (!path.startsWith(rule2)) return false;
+    if (!path.endsWith("*") && path != rule2) return false;
+    return true;
+  });
+  if (rules.length <= 0) {
+    return "";
+  }
+  const rule = rules.reduce((prev, curr) => {
+    if (curr.split("/").length > prev.split("/").length) return curr;
+    return prev;
+  });
+  return routeRules[rule];
+};

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugin.js

@@ -0,0 +1,24 @@
+import { defineNuxtPlugin } from "#app";
+import { getActiveLoader } from "./lib/utils/route-rules.js";
+import { useLoader } from "./composables/useLoader.js";
+export default defineNuxtPlugin((nuxt) => {
+  const pageLoadingStartHooks = ["page:loading:start", "app:created"];
+  const pageLoadingEndHooks = ["page:loading:end", "app:mounted"];
+  const states = useLoader();
+  const { isLoading } = states;
+  const ctx = nuxt.$config.public.loaders;
+  const { autoSetup, routeRules } = ctx;
+  if (autoSetup) {
+    nuxt.hooks.beforeEach((e) => {
+      if (pageLoadingStartHooks.includes(e.name)) {
+        const newActive = getActiveLoader(routeRules, nuxt._route.fullPath);
+        if (newActive && newActive !== ctx._activeLoader) {
+          ctx._activeLoader = newActive;
+        }
+        isLoading.value = true;
+      } else if (pageLoadingEndHooks.includes(e.name)) {
+        isLoading.value = false;
+      }
+    });
+  }
+});

package/dist/runtime/plugins/loader-registry.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/loader-registry.js

@@ -0,0 +1,16 @@
+import { defineNuxtPlugin } from "#app";
+import { markRaw } from "vue";
+export default defineNuxtPlugin((nuxtApp) => {
+  const loaderRegistry = /* @__PURE__ */ new Map();
+  nuxtApp.provide("loaderRegistry", {
+    register: (name, component) => {
+      loaderRegistry.set(name, markRaw(component));
+    },
+    get: (name) => {
+      return loaderRegistry.get(name);
+    },
+    has: (name) => {
+      return loaderRegistry.has(name);
+    }
+  });
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/runtime/tailwind.css

@@ -0,0 +1 @@
+@import "tailwindcss";

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "nuxt-loaders",
+  "version": "1.0.0",
+  "description": "My new Nuxt module",
+  "repository": "your-org/my-module",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "loaders": "./dist/bin/loaders.mjs"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^4.2.1",
+    "@tailwindcss/vite": "^4.1.18",
+    "tailwindcss": "^4.1.18"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.1.1",
+    "@nuxt/eslint-config": "^1.11.0",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.2.1",
+    "@nuxt/test-utils": "^3.21.0",
+    "@types/node": "^25.0.3",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "nuxt": "^4.2.1",
+    "ts-node": "^10.9.2",
+    "typescript": "~5.9.3",
+    "vitest": "^3.2.0",
+    "vue-tsc": "^3.1.7"
+  },
+  "scripts": {
+    "dev": "npm run dev:prepare && nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "cli:build": "tsc",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  }
+}