vueless 1.1.1-beta.8 → 1.2.0

package/ui.text-number/UNumber.vue

@@ -1,14 +1,14 @@
 <script setup lang="ts">
 import { computed, useTemplateRef } from "vue";
 
-import useUI from "../composables/useUI.ts";
-import { getDefaults } from "../utils/ui.ts";
+import useUI from "../composables/useUI";
+import { getDefaults } from "../utils/ui";
 
-import { COMPONENT_NAME } from "./constants.ts";
-import defaultConfig from "./config.ts";
-import { separatedNumber, MATH_SIGN_TYPE, MATH_SIGN } from "./utilNumber.ts";
+import { COMPONENT_NAME } from "./constants";
+import defaultConfig from "./config";
+import { separatedNumber, MATH_SIGN_TYPE, MATH_SIGN } from "./utilNumber";
 
-import type { Props, Config } from "./types.ts";
+import type { Props, Config } from "./types";
 
 defineOptions({ inheritAttrs: false });
 

package/ui.text-number/storybook/docs.mdx

@@ -1,8 +1,8 @@
 import { Meta, Title, Subtitle, Description, Primary, Controls, Stories, Source } from "@storybook/addon-docs/blocks";
-import { getSource } from "../../utils/storybook.ts";
+import { getSource } from "../../utils/storybook";
 
-import * as stories from "./stories.ts";
-import defaultConfig from "../config.ts?raw"
+import * as stories from "./stories";
+import defaultConfig from "../config?raw"
 
 <Meta of={stories} />
 <Title of={stories} />

package/ui.text-number/storybook/stories.ts

@@ -1,4 +1,10 @@
-import { getArgs, getArgTypes, getSlotNames, getSlotsFragment } from "../../utils/storybook.ts";
+import {
+  getArgs,
+  getArgTypes,
+  getSlotNames,
+  getSlotsFragment,
+  getDocsDescription,
+} from "../../utils/storybook";
 
 import UNumber from "../../ui.text-number/UNumber.vue";
 import UIcon from "../../ui.image-icon/UIcon.vue";
@@ -6,7 +12,7 @@ import URow from "../../ui.container-row/URow.vue";
 import UCol from "../../ui.container-col/UCol.vue";
 
 import type { Meta, StoryFn } from "@storybook/vue3-vite";
-import type { Props } from "../types.ts";
+import type { Props } from "../types";
 
 interface UNumberArgs extends Props {
   slotTemplate?: string;
@@ -23,6 +29,11 @@ export default {
   argTypes: {
     ...getArgTypes(UNumber.__name),
   },
+  parameters: {
+    docs: {
+      ...getDocsDescription(UNumber.__name),
+    },
+  },
 } as Meta;
 
 const DefaultTemplate: StoryFn<UNumberArgs> = (args: UNumberArgs) => ({

package/ui.text-number/tests/UNumber.test.ts

@@ -2,9 +2,9 @@ import { mount } from "@vue/test-utils";
 import { describe, it, expect, beforeAll } from "vitest";
 
 import UNumber from "../UNumber.vue";
-import { MATH_SIGN, MATH_SIGN_TYPE } from "../utilNumber.ts";
+import { MATH_SIGN, MATH_SIGN_TYPE } from "../utilNumber";
 
-import type { Props } from "../types.ts";
+import type { Props } from "../types";
 
 describe("UNumber.vue", () => {
   let value: number;

package/ui.text-number/types.ts

@@ -1,5 +1,5 @@
-import defaultConfig from "./config.ts";
-import type { ComponentConfig } from "../types.ts";
+import defaultConfig from "./config";
+import type { ComponentConfig } from "../types";
 
 export type Config = typeof defaultConfig;
 

package/utils/helper.ts

@@ -1,4 +1,4 @@
-import type { UnknownObject } from "../types.ts";
+import type { UnknownObject } from "../types";
 import { Comment, Text, Fragment } from "vue";
 
 import type { Slot, VNode } from "vue";

package/utils/node/dynamicProps.d.ts

@@ -0,0 +1,2 @@
+export function setCustomPropTypes(srcDir: any): Promise<void>;
+export function removeCustomPropTypes(srcDir: any): Promise<void>;

package/utils/node/dynamicProps.js

@@ -2,9 +2,11 @@ import fs from "node:fs/promises";
 import { existsSync } from "node:fs";
 import path from "node:path";
 
+import { removeFolderIfEmpty } from "./helper.js";
 import { vuelessConfig } from "./vuelessConfig.js";
 
 import {
+  CACHE_DIR,
   COMPONENTS,
   GRAYSCALE_COLOR,
   INHERIT_COLOR,
@@ -74,9 +76,8 @@ export async function setCustomPropTypes(srcDir) {
     }
 
     const isCustomProps = componentGlobalConfig && componentGlobalConfig.props;
-    const isHiddenStories = componentGlobalConfig && componentGlobalConfig.storybook === false;
 
-    if (isCustomProps && !isHiddenStories) {
+    if (isCustomProps) {
       await cacheComponentTypes(path.join(srcDir, componentDir));
       await modifyComponentTypes(path.join(srcDir, componentDir), componentGlobalConfig.props);
     }
@@ -91,26 +92,34 @@ export async function removeCustomPropTypes(srcDir) {
 }
 
 async function cacheComponentTypes(filePath) {
-  const cacheDir = path.join(filePath, ".cache");
+  const cacheDir = path.join(filePath, CACHE_DIR);
   const sourceFile = path.join(filePath, "types.ts");
   const destFile = path.join(cacheDir, "types.ts");
 
-  if (existsSync(cacheDir)) {
+  if (existsSync(destFile) || !existsSync(sourceFile)) {
     return;
   }
 
-  if (existsSync(sourceFile)) {
+  if (!existsSync(cacheDir)) {
     await fs.mkdir(cacheDir);
-    await fs.cp(sourceFile, destFile);
   }
+
+  await fs.cp(sourceFile, destFile);
 }
 
 async function clearComponentTypesCache(filePath) {
-  await fs.rm(path.join(filePath, ".cache"), { force: true, recursive: true });
+  const cacheDir = path.join(filePath, CACHE_DIR);
+  const sourceFile = path.join(cacheDir, "types.ts");
+
+  if (existsSync(sourceFile)) {
+    await fs.rm(sourceFile, { force: true });
+  }
+
+  await removeFolderIfEmpty(cacheDir);
 }
 
 async function restoreComponentTypes(filePath) {
-  const cacheDir = path.join(filePath, ".cache");
+  const cacheDir = path.join(filePath, CACHE_DIR);
   const sourceFile = path.join(cacheDir, "types.ts");
   const destFile = path.join(filePath, "types.ts");
 

package/utils/node/helper.d.ts

@@ -0,0 +1,15 @@
+export function getDirFiles(dirPath: any, ext: any, { recursive, exclude }?: {
+    recursive?: boolean | undefined;
+    exclude?: never[] | undefined;
+}): Promise<string[]>;
+export function getNuxtDirs(): string[];
+export function getVueDirs(): string[];
+export function getVuelessConfigDirs(): string[];
+export function getMergedComponentConfig(name: any): Promise<any>;
+export function getDefaultComponentConfig(name: any, configDir: any): Promise<{}>;
+export function cacheMergedConfigs(srcDir: any): Promise<void>;
+export function buildTSFile(entryPath: any, configOutFile: any): Promise<void>;
+export function removeFolderIfEmpty(dirPath: any): Promise<void>;
+export function detectTypeScript(): Promise<boolean>;
+export function autoImportUserConfigs(basePath?: string): Promise<void>;
+export function generateConfigIndexContent(imports?: string[], componentEntries?: string[]): Promise<string>;

package/utils/node/helper.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { cwd } from "node:process";
 import { pathToFileURL } from "node:url";
 import { existsSync, statSync } from "node:fs";
-import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readdir, rmdir, readFile, writeFile } from "node:fs/promises";
 
 import { vuelessConfig, getMergedConfig } from "./vuelessConfig.js";
 
@@ -11,15 +11,14 @@ import {
   COMPONENTS,
   JAVASCRIPT_EXT,
   TYPESCRIPT_EXT,
-  VUELESS_CONFIGS_CACHED_DIR,
-  VUELESS_MERGED_CONFIGS_CACHED_DIR,
-} from "../../constants.js";
-
-import {
   SUPPRESS_TS_CHECK,
+  VUELESS_CONFIG_DIR,
   COMPONENTS_INDEX_EXPORT,
   COMPONENTS_INDEX_COMMENT,
-} from "../../bin/constants.js";
+  VUELESS_CONFIGS_CACHED_DIR,
+  VUELESS_MERGED_CONFIGS_CACHED_DIR,
+  CONFIG_INDEX_FILE_NAME,
+} from "../../constants.js";
 
 export async function getDirFiles(dirPath, ext, { recursive = true, exclude = [] } = {}) {
   let fileNames = [];
@@ -68,6 +67,7 @@ export async function getDirFiles(dirPath, ext, { recursive = true, exclude = []
 
 export function getNuxtDirs() {
   return [
+    path.join(cwd(), "app"),
     path.join(cwd(), "composables"),
     path.join(cwd(), "components"),
     path.join(cwd(), "layouts"),
@@ -87,7 +87,7 @@ export function getVueDirs() {
 }
 
 export function getVuelessConfigDirs() {
-  return [path.join(cwd(), ".vueless")];
+  return [path.join(cwd(), VUELESS_CONFIG_DIR)];
 }
 
 export async function getMergedComponentConfig(name) {
@@ -157,25 +157,64 @@ export async function buildTSFile(entryPath, configOutFile) {
   });
 }
 
-export async function autoImportUserConfigs() {
-  const vuelessConfigDir = path.join(cwd(), ".vueless");
+export async function removeFolderIfEmpty(dirPath) {
+  if (existsSync(dirPath)) {
+    const files = await readdir(dirPath);
+
+    if (!files.length) {
+      await rmdir(dirPath);
+    }
+  }
+}
+
+/**
+ * Detects if TypeScript is a dependency in the project's package.json
+ * @returns {Promise<boolean>} True if TypeScript is found in dependencies or devDependencies
+ */
+export async function detectTypeScript() {
+  try {
+    const packageJsonPath = path.join(cwd(), "package.json");
+    const packageJsonContent = await readFile(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(packageJsonContent);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
 
-  const indexTsPath = path.join(vuelessConfigDir, "index.ts");
-  const indexJsPath = path.join(vuelessConfigDir, "index.js");
+    return Boolean(deps.typescript);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (error) {
+    return false;
+  }
+}
 
-  const hasTsIndex = existsSync(indexTsPath);
-  const indexFilePath = hasTsIndex ? indexTsPath : indexJsPath;
-  const fileExt = hasTsIndex ? TYPESCRIPT_EXT : JAVASCRIPT_EXT;
+/**
+ * Automatically imports user configuration files from a specified directory, generates index file entries for them,
+ * and writes the configuration index file in the appropriate format (TypeScript or JavaScript).
+ *
+ * @param {string} [basePath=""] The base directory path where the user configuration files are located.
+ * @return {Promise<void>} A promise that resolves when the configuration import and index file generation is completed.
+ */
+export async function autoImportUserConfigs(basePath = "") {
+  const vuelessConfigDir = path.join(cwd(), basePath, VUELESS_CONFIG_DIR);
+
+  const indexTsPath = path.join(vuelessConfigDir, `${CONFIG_INDEX_FILE_NAME}${TYPESCRIPT_EXT}`);
+  const indexJsPath = path.join(vuelessConfigDir, `${CONFIG_INDEX_FILE_NAME}${JAVASCRIPT_EXT}`);
+
+  const hasTypeScript = await detectTypeScript();
+
+  const indexFilePath = hasTypeScript ? indexTsPath : indexJsPath;
+  const fileExt = hasTypeScript ? TYPESCRIPT_EXT : JAVASCRIPT_EXT;
 
   const configFiles = await getDirFiles(vuelessConfigDir, fileExt, {
     recursive: true,
-    exclude: ["index.ts", "index.js"],
+    exclude: [
+      `${CONFIG_INDEX_FILE_NAME}${TYPESCRIPT_EXT}`,
+      `${CONFIG_INDEX_FILE_NAME}${JAVASCRIPT_EXT}`,
+    ],
   });
 
   const componentConfigFiles = configFiles.filter((filePath) => {
     const fileName = path.basename(filePath);
 
-    return /^U\w+\.config\.(ts|js)$/.test(fileName);
+    return /^U\w+\.(ts|js)$/.test(fileName);
   });
 
   const imports = [];
@@ -184,12 +223,11 @@ export async function autoImportUserConfigs() {
   if (componentConfigFiles.length) {
     for (const configFilePath of componentConfigFiles) {
       const fileName = path.basename(configFilePath, path.extname(configFilePath));
-      const componentName = fileName.replace(".config", "");
       const relativePath = path.relative(vuelessConfigDir, configFilePath);
       const importPath = "./" + relativePath.replace(/\\/g, "/");
 
-      imports.push(`import ${componentName} from "${importPath}";`);
-      componentEntries.push(`  ${componentName},`);
+      imports.push(`import ${fileName} from "${importPath}";`);
+      componentEntries.push(`  ${fileName},`);
     }
   }
 
@@ -197,17 +235,25 @@ export async function autoImportUserConfigs() {
     await mkdir(vuelessConfigDir, { recursive: true });
   }
 
-  await writeFile(
-    indexFilePath,
-    generateConfigIndexContent(imports, componentEntries, hasTsIndex),
-    "utf-8",
-  );
+  const indexFileContent = await generateConfigIndexContent(imports, componentEntries);
+
+  await writeFile(indexFilePath, indexFileContent, "utf-8");
 }
 
-function generateConfigIndexContent(imports = [], componentEntries = [], isTypeScript) {
+/**
+ * Generates the content for a configuration index file by combining imports, component entries,
+ * and TypeScript-related handling.
+ *
+ * @param {string[]} imports - An array of import statements to include in the configuration index file.
+ * @param {string[]} componentEntries - An array of component entry definitions to export in the configuration index file.
+ * @return {Promise<string>} The constructed configuration indexes file content as a string.
+ */
+export async function generateConfigIndexContent(imports = [], componentEntries = []) {
   const importsSection = imports.length ? `\n${imports.join("\n")}\n\n` : "";
   const entriesSection = componentEntries.length ? `\n${componentEntries.join("\n")}\n` : "";
-  const suppressTsCheck = isTypeScript ? `${SUPPRESS_TS_CHECK}\n` : "";
+
+  const hasTypeScript = await detectTypeScript();
+  const suppressTsCheck = hasTypeScript ? `${SUPPRESS_TS_CHECK}\n` : "";
 
   return `${suppressTsCheck}${COMPONENTS_INDEX_COMMENT}\n${importsSection}${COMPONENTS_INDEX_EXPORT.replace(
     "{}",

package/utils/node/loaderIcon.d.ts

@@ -0,0 +1,7 @@
+export function createIconsCache({ env, debug, targetFiles }?: string): Promise<void>;
+export function removeIconsCache(basePath: string, isVuelessEnv?: boolean): Promise<void>;
+export function copyIconsCache(basePath: string, isVuelessEnv?: boolean): Promise<void>;
+export function generateIconExports(): string;
+export function reloadServerOnIconsCacheUpdate(server: Object): void;
+export function extractIconLines(content: string): string[];
+export function isIconChanged(currentLines: string[], previousLines: string[]): boolean;

package/utils/node/loaderIcon.js

@@ -77,18 +77,20 @@ export async function createIconsCache({ env, debug = false, targetFiles = [] }
 
 /**
  * Remove cached icons.
- * @param {string} mirrorCacheDir
+ * @param {string} basePath
+ * @param {boolean} isVuelessEnv
  * @returns {Promise<void>}
  */
-export async function removeIconsCache(mirrorCacheDir) {
+export async function removeIconsCache(basePath, isVuelessEnv = false) {
   const cachePath = path.join(cwd(), ICONS_CACHED_DIR);
 
   if (fs.existsSync(cachePath)) {
     await rm(cachePath, { recursive: true, force: true });
   }
 
-  if (mirrorCacheDir) {
-    const mirrorCacheIconsPath = path.join(cwd(), mirrorCacheDir, ICONS_DIR);
+  if (basePath) {
+    const iconsDir = isVuelessEnv ? ICONS_DIR : ICONS_CACHED_DIR;
+    const mirrorCacheIconsPath = path.join(cwd(), basePath, iconsDir);
 
     if (fs.existsSync(mirrorCacheIconsPath)) {
       await rm(mirrorCacheIconsPath, { recursive: true, force: true });
@@ -98,14 +100,16 @@ export async function removeIconsCache(mirrorCacheDir) {
 
 /**
  * Copy cached icons in the provided folder by path.
- * @param {string} mirrorCacheDir
+ * @param {string} basePath
+ * @param {boolean} isVuelessEnv
  * @returns {Promise<void>}
  */
-export async function copyIconsCache(mirrorCacheDir) {
+export async function copyIconsCache(basePath, isVuelessEnv = false) {
   const cachePath = path.join(cwd(), ICONS_CACHED_DIR);
 
-  if (mirrorCacheDir && fs.existsSync(cachePath)) {
-    const mirrorPath = path.join(cwd(), mirrorCacheDir, ICONS_DIR);
+  if (basePath && fs.existsSync(cachePath)) {
+    const iconsDir = isVuelessEnv ? ICONS_DIR : ICONS_CACHED_DIR;
+    const mirrorPath = path.join(cwd(), basePath, iconsDir);
 
     await cp(cachePath, mirrorPath, { recursive: true });
   }

package/utils/node/loaderSvg.d.ts

@@ -0,0 +1 @@
+export function loadSvg(id: any, options: any): Promise<string | undefined>;

package/utils/node/mergeConfigs.d.ts

@@ -0,0 +1,13 @@
+export function createMergeConfigs(cx: any): ({ defaultConfig, globalConfig, propsConfig, config, isVariants, }: {
+    defaultConfig: any;
+    globalConfig: any;
+    propsConfig: any;
+    config?: {} | undefined;
+    isVariants?: boolean | undefined;
+}) => {};
+export function createGetMergedConfig(cx: any): ({ defaultConfig, globalConfig, propsConfig, unstyled }: {
+    defaultConfig: any;
+    globalConfig: any;
+    propsConfig: any;
+    unstyled: any;
+}) => {};

package/utils/node/storybook.d.ts

@@ -0,0 +1,2 @@
+export function defineConfigWithVueless(config: Object): Promise<Object>;
+export function getVuelessStoriesGlob(vuelessEnv: string, basePath: string): Promise<string[]>;

package/utils/node/storybook.js

@@ -0,0 +1,93 @@
+import { getVuelessConfig } from "./vuelessConfig.js";
+import { autoImportUserConfigs } from "./helper.js";
+import {
+  COMPONENTS,
+  DIRECTIVES,
+  INTERNAL_ENV,
+  VUELESS_LOCAL_DIR,
+  VUELESS_PACKAGE_DIR,
+} from "../../constants.js";
+
+/**
+ * Defines the config for Storybook.
+ *
+ * @param {Object} config - The config object.
+ * @return {Promise<Object>} A promise that resolves to the modified config object.
+ */
+export function defineConfigWithVueless(config) {
+  return (async () => ({
+    ...config,
+    stories: [
+      ...config.stories,
+      ...(await getVuelessStoriesGlob(config?.vuelessEnv, config?.basePath)),
+    ],
+    addons: [
+      ...new Set([
+        ...(config.addons || []),
+        "@storybook/addon-docs",
+        "@storybook/addon-links",
+        "@vueless/storybook-dark-mode",
+        "@storybook/addon-themes",
+      ]),
+    ],
+    framework: {
+      ...config.framework,
+      name: "@storybook/vue3-vite",
+      options: {
+        ...config.framework?.options,
+        builder: {
+          ...config.framework?.options?.builder,
+          viteConfigPath: ".storybook/vite.config.js",
+        },
+      },
+    },
+    env: (envConfig) => ({
+      ...envConfig,
+      BASE_URL: "/",
+    }),
+  }))();
+}
+
+/**
+ * Retrieves the glob pattern for Vueless stories based on the provided Vueless environment.
+ *
+ * @param {string} vuelessEnv - The Vueless environment.
+ * @param {string} basePath - The Project base path.
+ * @return {Promise<string[]>} A promise that resolves to an array of glob patterns for Vueless stories.
+ */
+export async function getVuelessStoriesGlob(vuelessEnv, basePath) {
+  /* Auto import user configs. */
+  await autoImportUserConfigs(basePath);
+
+  const vuelessSrcDir = vuelessEnv === INTERNAL_ENV ? VUELESS_LOCAL_DIR : VUELESS_PACKAGE_DIR;
+  const vuelessConfig = await getVuelessConfig();
+  const storiesGlob = [];
+
+  for (const [directiveName, directiveDir] of Object.entries(DIRECTIVES)) {
+    const directiveGlobalConfig = vuelessConfig.directives?.[directiveName];
+    const isHiddenStoriesByDirective = directiveGlobalConfig === false;
+    const isHiddenStoriesByKey = directiveGlobalConfig?.storybook === false;
+
+    if (isHiddenStoriesByDirective || isHiddenStoriesByKey) {
+      continue;
+    }
+
+    storiesGlob.push(`../${vuelessSrcDir}/${directiveDir}/storybook/stories.{js,ts}`);
+    storiesGlob.push(`../${vuelessSrcDir}/${directiveDir}/storybook/docs.mdx`);
+  }
+
+  for (const [componentName, componentDir] of Object.entries(COMPONENTS)) {
+    const componentGlobalConfig = vuelessConfig.components?.[componentName];
+    const isHiddenStoriesByComponent = componentGlobalConfig === false;
+    const isHiddenStoriesByKey = componentGlobalConfig?.storybook === false;
+
+    if (isHiddenStoriesByComponent || isHiddenStoriesByKey) {
+      continue;
+    }
+
+    storiesGlob.push(`../${vuelessSrcDir}/${componentDir}/storybook/stories.{js,ts}`);
+    storiesGlob.push(`../${vuelessSrcDir}/${componentDir}/storybook/docs.mdx`);
+  }
+
+  return storiesGlob;
+}

package/utils/node/tailwindSafelist.d.ts

@@ -0,0 +1,6 @@
+export function clearTailwindSafelist(): Promise<void>;
+export function createTailwindSafelist({ env, srcDir, targetFiles }?: {
+    env: string;
+    srcDir: string;
+    targetFiles?: string[] | undefined;
+}): Promise<void>;

package/utils/node/vuelessConfig.d.ts

@@ -0,0 +1,9 @@
+export function getVuelessConfig(basePath?: string): Promise<Object>;
+export let vuelessConfig: {};
+export const cx: import("cva").CX;
+export const getMergedConfig: ({ defaultConfig, globalConfig, propsConfig, unstyled }: {
+    defaultConfig: any;
+    globalConfig: any;
+    propsConfig: any;
+    unstyled: any;
+}) => {};

package/utils/node/vuelessConfig.js

@@ -3,10 +3,10 @@ import path from "node:path";
 import { cwd } from "node:process";
 import { pathToFileURL } from "node:url";
 import { defineConfig } from "cva";
-import { createGetMergedConfig } from "./mergeConfigs.js";
 import { merge } from "lodash-es";
 import { extendTailwindMerge } from "tailwind-merge";
 
+import { createGetMergedConfig } from "./mergeConfigs.js";
 import { buildTSFile } from "./helper.js";
 import {
   VUELESS_CACHE_DIR,
@@ -15,21 +15,33 @@ import {
   NESTED_COMPONENT_PATTERN_REG_EXP,
 } from "../../constants.js";
 
+export let vuelessConfig = {};
+
 /**
  * Load Vueless config from the project root.
  * IIFE is used to prevent top level await issue.
  */
-export let vuelessConfig = {};
-
 (async () => {
-  const configPathJs = path.join(cwd(), `${VUELESS_CONFIG_FILE_NAME}.js`);
-  const configPathTs = path.join(cwd(), `${VUELESS_CONFIG_FILE_NAME}.ts`);
-  const configOutPath = path.join(cwd(), `${VUELESS_CACHE_DIR}/${VUELESS_CONFIG_FILE_NAME}.mjs`);
+  vuelessConfig = await getVuelessConfig();
+})();
 
-  if (!fs.existsSync(configPathJs) && !fs.existsSync(configPathTs)) {
-    vuelessConfig = {};
+/**
+ * Retrieves the Vueless config from the project root.
+ *
+ * This method checks for the existence of a `vueless.config.{js,ts}` file in the project root.
+ * If the file exists, it reads the config and returns it as an object.
+ * @param {string} basePath - The application base path.
+ *
+ * @return {Promise<Object>} A promise that resolves to the Vueless configuration object.
+ */
+export async function getVuelessConfig(basePath = "") {
+  const configPathJs = path.join(cwd(), basePath, `${VUELESS_CONFIG_FILE_NAME}.js`);
+  const configPathTs = path.join(cwd(), basePath, `${VUELESS_CONFIG_FILE_NAME}.ts`);
+  // eslint-disable-next-line prettier/prettier
+  const configOutPath = path.join(cwd(), basePath, `${VUELESS_CACHE_DIR}/${VUELESS_CONFIG_FILE_NAME}.mjs`);
 
-    return;
+  if (!fs.existsSync(configPathJs) && !fs.existsSync(configPathTs)) {
+    return {};
   }
 
   fs.existsSync(configPathJs) && (await buildTSFile(configPathJs, configOutPath));
@@ -38,16 +50,23 @@ export let vuelessConfig = {};
   if (fs.existsSync(configOutPath)) {
     const module = await import(pathToFileURL(configOutPath));
 
-    vuelessConfig = module.default;
+    return module.default;
   }
-})();
+}
 
+/* Merge tailwind classes with removing duplicates. */
 const twMerge = extendTailwindMerge(merge(TAILWIND_MERGE_EXTENSION, vuelessConfig.tailwindMerge));
 
+/**
+ * Export cx (class merge) method:
+ * – extended with tailwind-merge
+ * – remove all Vueless nested component names ({U...} strings) from the class list string.
+ */
 export const { cx } = defineConfig({
   hooks: {
     onComplete: (classNames) => twMerge(classNames).replace(NESTED_COMPONENT_PATTERN_REG_EXP, ""),
   },
 });
 
+/* Get merged config based on config merging strategy. */
 export const getMergedConfig = createGetMergedConfig(cx);

package/utils/node/vuelessResolver.d.ts

@@ -0,0 +1,13 @@
+export namespace componentResolver {
+    let type: string;
+    function resolve(componentName: any): {
+        from: string;
+    } | undefined;
+}
+export namespace directiveResolver {
+    let type_1: string;
+    export { type_1 as type };
+    export function resolve(directive: any): {
+        from: string;
+    } | undefined;
+}