auklet 0.0.19 → 0.0.21

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 import type { AukletConfig, StyleDependencyGroup } from '#auklet/types';
-export declare const aukletConfigFile = "auklet.config.ts";
+export declare const aukletConfigFiles: string[];
+export declare function isAukletConfigFile(file: string): boolean;
 export declare const aukletDefaultOptions: {
     source: string;
     output: string;
@@ -42,3 +43,4 @@ export declare function normalizeAukletConfig(config?: AukletConfig): {
         };
     };
 };
+export declare function defineConfig(config: AukletConfig): AukletConfig;

package/dist/config.js

@@ -1,4 +1,7 @@
-export const aukletConfigFile = 'auklet.config.ts';
+export const aukletConfigFiles = ['auklet.config.js', 'auklet.config.mjs'];
+export function isAukletConfigFile(file) {
+    return aukletConfigFiles.includes(file);
+}
 export const aukletDefaultOptions = {
     source: 'src',
     output: 'dist',
@@ -45,3 +48,6 @@ export function normalizeAukletConfig(config = {}) {
         },
     };
 }
+export function defineConfig(config) {
+    return config;
+}

package/dist/configLoader.d.ts

@@ -1,3 +1,4 @@
 import type { AukletConfig, LoadAukletConfigOptions } from '#auklet/types';
+export declare function resolveAukletConfigPath(packageRoot: string, configFile?: string): string | null;
 export declare function resolveAukletConfigModule(module: Record<string, unknown>): AukletConfig;
 export declare function loadAukletConfig(packageRoot: string, options?: LoadAukletConfigOptions): Promise<AukletConfig>;

package/dist/configLoader.js

@@ -1,79 +1,60 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import ts from 'typescript';
-import { aukletConfigFile } from '#auklet/config';
-const importAukletConfigModule = async (configPath, href) => {
-    try {
-        return (await import(href));
-    }
-    catch (error) {
-        if (!isUnknownTsExtensionError(error) || !configPath.endsWith('.ts')) {
-            throw error;
-        }
-        return importTsOptionsModule(href);
-    }
-};
-const importTsOptionsModule = async (href) => {
-    const configPath = fileURLToPath(href);
-    const source = fs.readFileSync(configPath, 'utf8');
-    const output = ts.transpileModule(source, {
-        compilerOptions: {
-            esModuleInterop: true,
-            module: ts.ModuleKind.ESNext,
-            target: ts.ScriptTarget.ES2020,
-        },
-        fileName: configPath,
-    });
-    const tempFile = path.join(path.dirname(configPath), `.auklet.config.${process.pid}.${Date.now()}.mjs`);
-    fs.writeFileSync(tempFile, output.outputText);
-    try {
-        return (await import(pathToFileURL(tempFile).href));
-    }
-    finally {
-        fs.rmSync(tempFile, { force: true });
-    }
+import { pathToFileURL } from 'node:url';
+import { isPlainObject } from 'aidly';
+import { aukletConfigFiles, isAukletConfigFile } from '#auklet/config';
+const asRecord = (value) => {
+    return isPlainObject(value) ? value : null;
 };
-const isUnknownTsExtensionError = (error) => {
-    return (error instanceof TypeError &&
-        'code' in error &&
-        error.code === 'ERR_UNKNOWN_FILE_EXTENSION');
+const assertSupportedConfigFile = (configFile) => {
+    const basename = path.basename(configFile);
+    if (isAukletConfigFile(basename))
+        return;
+    throw new Error('[auklet] unsupported config file: ' +
+        basename +
+        '. Use auklet.config.js or auklet.config.mjs and export `config`.');
 };
-const asRecord = (value) => {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+export function resolveAukletConfigPath(packageRoot, configFile) {
+    if (!fs.existsSync(packageRoot))
         return null;
+    if (configFile) {
+        assertSupportedConfigFile(configFile);
+        const configPath = path.join(packageRoot, configFile);
+        return fs.existsSync(configPath) ? configPath : null;
+    }
+    const configPaths = aukletConfigFiles
+        .map((file) => path.join(packageRoot, file))
+        .filter((file) => fs.existsSync(file));
+    if (configPaths.length > 1) {
+        throw new Error('[auklet] found multiple config files: ' +
+            configPaths.map((file) => path.basename(file)).join(', ') +
+            '. Keep only one auklet config file.');
+    }
+    if (configPaths[0])
+        return configPaths[0];
+    for (const file of fs.readdirSync(packageRoot)) {
+        if (file.startsWith('auklet.config.') && !isAukletConfigFile(file)) {
+            assertSupportedConfigFile(file);
+        }
     }
-    return value;
-};
+    return null;
+}
 export function resolveAukletConfigModule(module) {
-    const candidates = [
-        module,
-        asRecord(module.default),
-        asRecord(module['module.exports']),
-    ];
-    for (const candidate of candidates) {
-        if (!candidate)
-            continue;
-        const config = asRecord(candidate.config);
-        if (config) {
-            return config;
-        }
+    const config = asRecord(module.config);
+    if (!config) {
+        throw new Error('[auklet] config file must export `config`.');
     }
-    return {};
+    return config;
 }
 export async function loadAukletConfig(packageRoot, options = {}) {
-    const configPath = path.join(packageRoot, options.configFile ?? aukletConfigFile);
-    if (!fs.existsSync(configPath)) {
+    const configPath = resolveAukletConfigPath(packageRoot, options.configFile);
+    if (!configPath) {
         return {};
     }
     const url = pathToFileURL(configPath);
     if (options.cacheBust) {
         url.searchParams.set('t', Date.now().toString());
     }
-    if (configPath.endsWith('.ts')) {
-        const module = await importTsOptionsModule(url.href);
-        return resolveAukletConfigModule(module);
-    }
-    const module = await importAukletConfigModule(configPath, url.href);
+    const module = (await import(url.href));
     return resolveAukletConfigModule(module);
 }

package/dist/css/production/buildReporter.d.ts

@@ -0,0 +1,3 @@
+import type { AukletLogger } from '#auklet/logger';
+import type { ModuleStyleBuildResult } from '#auklet/types';
+export declare function logModuleStyleBuildResult(logger: AukletLogger, result: ModuleStyleBuildResult, elapsed: number): void;

package/dist/css/production/buildReporter.js

@@ -0,0 +1,19 @@
+import path from 'node:path';
+export function logModuleStyleBuildResult(logger, result, elapsed) {
+    logger.step(`Build ${path.basename(result.packageRoot)}`);
+    logger.item(logger.colors.bold(logger.colors.yellow(String(result.styleFiles.length))), logger.colors.bold(logger.colors.white(' source style file(s), ')), logger.colors.bold(logger.colors.yellow(String(result.outputs.length))), logger.colors.bold(logger.colors.white(' output entry file(s)')));
+    if (result.outputs.length) {
+        const rows = result.outputs.map((output) => [
+            logger.path(path.relative(result.packageRoot, output.file)),
+            `${(output.size / 1000).toFixed(2)} kB`,
+        ]);
+        const sizeWidth = Math.max(...rows.map(([, size]) => String(size).length));
+        logger.rows({
+            rows: rows.map(([file, size]) => [
+                file,
+                logger.colors.gray(String(size).padStart(sizeWidth)),
+            ]),
+        });
+    }
+    logger.success('Build complete in ', logger.duration(elapsed));
+}

package/dist/css/production/builder.d.ts

@@ -2,10 +2,15 @@ import type { ModuleStyleBuildConfig, ModuleStyleBuildContext, ModuleStyleBuildO
 export declare class ModuleStyleBuilder {
     private readonly config;
     private readonly context;
-    private readonly logger?;
     constructor(context?: ModuleStyleBuildContext, config?: ModuleStyleBuildConfig);
-    build(options?: ModuleStyleBuildOptions): Promise<void>;
-    private logOutputs;
+    build(options?: ModuleStyleBuildOptions): Promise<{
+        packageRoot: string;
+        styleFiles: string[];
+        outputs: {
+            file: string;
+            size: number;
+        }[];
+    }>;
     private createBuildContext;
     private createPackageContext;
 }

package/dist/css/production/builder.js

@@ -1,14 +1,12 @@
-import path from 'node:path';
+import fs from 'node:fs';
 import { normalizeAukletConfig } from '#auklet/config';
 import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 import { ModuleStyleOutputWriter } from '#auklet/css/production/moduleOutputWriter';
 import { PackageStyleEntryWriter } from '#auklet/css/production/packageEntryWriter';
-import { toPosixPath } from '#auklet/utils';
 export class ModuleStyleBuilder {
     config;
     context;
-    logger;
     constructor(context = {}, config = moduleStyleBuildConfig) {
         this.config = config;
         this.context = {
@@ -17,12 +15,10 @@ export class ModuleStyleBuilder {
             output: context.output,
             ...context,
         };
-        this.logger = context.logger;
     }
     async build(options = {}) {
         const rawConfig = options.aukletConfig ?? this.context.aukletConfig ?? {};
         const normalizedConfig = normalizeAukletConfig(rawConfig);
-        const logger = options.logger ?? this.logger;
         const context = this.createBuildContext(normalizedConfig);
         const packageContext = this.createPackageContext(context, normalizedConfig);
         const writerOptions = {
@@ -33,17 +29,17 @@ export class ModuleStyleBuilder {
         const packageWriter = new PackageStyleEntryWriter(writerOptions);
         const packageOutput = packageWriter.write();
         const outputs = packageOutput ? [packageOutput] : [];
-        logger?.log?.(`[auklet:css] build ${path.basename(context.packageRoot)}`);
         if (normalizedConfig.modules) {
             outputs.push(...new ModuleStyleOutputWriter(writerOptions).write());
         }
-        this.logOutputs(context, packageContext.styleFiles, outputs, logger);
-    }
-    logOutputs(context, styleFiles, outputs, logger) {
-        logger?.log?.(`[auklet:css] ${styleFiles.length} source style file(s), ${outputs.length} output entry file(s)`);
-        for (const output of outputs) {
-            logger?.log?.(`[auklet:css] + ${toPosixPath(path.relative(context.packageRoot, output))}`);
-        }
+        return {
+            packageRoot: context.packageRoot,
+            styleFiles: packageContext.styleFiles,
+            outputs: outputs.map((file) => ({
+                file,
+                size: fs.statSync(file).size,
+            })),
+        };
     }
     createBuildContext(config) {
         return {

package/dist/css/vite/hmr.js

@@ -1,15 +1,17 @@
 import path from 'node:path';
+import { isString } from 'aidly';
 import { normalizeFileKey } from '#auklet/utils';
+import { createScopedAukletLogger } from '#auklet/logger';
 // package CSS 的 HMR 不能直接走 Vite 原生 CSS 文件链路：
-// - 浏览器 import 的是 auklet-css:* 虚拟 CSS 模块，不是真实的
+// 1. 浏览器 import 的是 auklet-css:* 虚拟 CSS 模块，不是真实的
 //   packages/*/src/**/*.css 文件，所以真实 CSS 变化时 Vite 的 modules 可能为空。
-// - Vite dev 会把 CSS 转成自接受的 JS 模块，重新执行模块里的 updateStyle()
+// 2. Vite dev 会把 CSS 转成自接受的 JS 模块，重新执行模块里的 updateStyle()
 //   才能更新样式，因此这里手动发送 js-update，而不是 css-update。
-// - @tailwindcss/vite 会在相关 CSS 变化时主动发 full-reload。package CSS 已由
+// 3. @tailwindcss/vite 会在相关 CSS 变化时主动发 full-reload。package CSS 已由
 //   这个插件接管 HMR 时，需要在一个很短的窗口内吞掉这次 reload。
-const HMR_LOG_PREFIX = '[auklet:css:vite]';
 const FULL_RELOAD_SUPPRESS_MS = 100;
 const DUPLICATE_UPDATE_IGNORE_MS = 500;
+const logger = createScopedAukletLogger('css:vite');
 const toBrowserVirtualPath = (id) => {
     return `/@id/${id.replace('\0', '__x00__')}`;
 };
@@ -58,13 +60,13 @@ export class AukletStyleHmr {
     installFullReloadGuard(server) {
         const send = server.ws.send.bind(server.ws);
         server.ws.send = ((payload, data) => {
-            if (typeof payload !== 'string' &&
+            if (!isString(payload) &&
                 payload.type === 'full-reload' &&
                 this.shouldSuppressFullReload()) {
-                console.info(`${HMR_LOG_PREFIX} suppressed package css full-reload`);
+                logger.info('suppressed package css full-reload');
                 return;
             }
-            if (typeof payload === 'string') {
+            if (isString(payload)) {
                 send(payload, data);
                 return;
             }
@@ -98,7 +100,7 @@ export class AukletStyleHmr {
                 isWithinCircularImport: false,
             };
         });
-        console.info(`${HMR_LOG_PREFIX} package css hmr ${getRelativeFile(context.file)} tracked=${virtualIds.length} updates=${updates.length}`);
+        logger.info(`package css hmr ${getRelativeFile(context.file)} tracked=${virtualIds.length} updates=${updates.length}`);
         if (updates.length) {
             context.server.ws.send({
                 type: 'update',

package/dist/css/vite/moduleGraph/graph.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { aukletConfigFile } from '#auklet/config';
+import { isAukletConfigFile } from '#auklet/config';
 import { loadAukletConfig } from '#auklet/configLoader';
 import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { parsePackageStyleId } from '#auklet/css/vite/moduleGraph/styleId';
@@ -22,7 +22,6 @@ export class ModuleStyleGraph {
             (options.mode ?? 'package') === 'monorepo'
                 ? new MonorepoPackageSource({
                     root: normalizeFileKey(options.root),
-                    packagesDir: options.packagesDir ?? 'packages',
                     styleExtensions: this.config.styleExtensions,
                 })
                 : new SinglePackageSource({
@@ -38,7 +37,7 @@ export class ModuleStyleGraph {
         return this.packageSource.isSourceGraphFile(file);
     }
     isStyleConfigFile(file) {
-        return normalizeFileKey(file).endsWith(aukletConfigFile);
+        return isAukletConfigFile(path.basename(normalizeFileKey(file)));
     }
     isStyleFile(file) {
         return this.config.styleExtensions.includes(path.extname(file));

package/dist/css/vite/moduleGraph/packageSource/monorepo.d.ts

@@ -1,18 +1,22 @@
+import type { WorkspacePackageInfo } from '#auklet/workspace/packages';
 import type { StylePackageInfo, StylePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/types';
 export type MonorepoPackageSourceOptions = {
     root: string;
-    packagesDir: string;
     styleExtensions: Array<string>;
+    readWorkspacePackages?: (root: string) => Array<WorkspacePackageInfo>;
 };
 export declare class MonorepoPackageSource implements StylePackageSource {
     private readonly options;
     private packages?;
     private packageNames?;
     private readonly root;
+    private readonly rawRoot;
     constructor(options: MonorepoPackageSourceOptions);
     getPackages(): StylePackageInfo[];
     getPackageNames(): string[];
     isKnownPackageName(packageName: string): boolean;
     isSourceGraphFile(file: string): boolean;
     getWatchRoots(): Promise<string[]>;
+    private getWorkspacePackages;
+    private isWorkspaceRootPackage;
 }

package/dist/css/vite/moduleGraph/packageSource/monorepo.js

@@ -1,43 +1,24 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { aukletConfigFile } from '#auklet/config';
+import { aukletConfigFiles, isAukletConfigFile } from '#auklet/config';
 import { SOURCE_MODULE_RE } from '#auklet/css/constants';
-import { normalizeFileKey, toWatchPath } from '#auklet/utils';
+import { normalizeFileKey, toPosixPath, toWatchPath } from '#auklet/utils';
+import { readPnpmWorkspacePackageInfoSync } from '#auklet/workspace/packages';
 export class MonorepoPackageSource {
     options;
     packages;
     packageNames;
     root;
+    rawRoot;
     constructor(options) {
         this.options = options;
         this.root = normalizeFileKey(options.root);
+        this.rawRoot = toPosixPath(path.resolve(options.root));
     }
     getPackages() {
         if (this.packages)
             return this.packages;
-        const packagesRoot = path.join(this.root, this.options.packagesDir);
-        if (!fs.existsSync(packagesRoot)) {
-            this.packages = [];
-            return this.packages;
-        }
-        this.packages = fs
-            .readdirSync(packagesRoot, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory())
-            .flatMap((entry) => {
-            const packageRoot = path.join(packagesRoot, entry.name);
-            const packageJsonPath = path.join(packageRoot, 'package.json');
-            if (!fs.existsSync(packageJsonPath))
-                return [];
-            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-            if (!pkg.name)
-                return [];
-            return [
-                {
-                    packageName: pkg.name,
-                    packageRoot,
-                },
-            ];
-        });
+        this.packages = this.getWorkspacePackages() ?? [];
         return this.packages;
     }
     getPackageNames() {
@@ -49,21 +30,49 @@ export class MonorepoPackageSource {
     }
     isSourceGraphFile(file) {
         const normalizedFile = normalizeFileKey(file);
-        const packagesRoot = normalizeFileKey(path.join(this.root, this.options.packagesDir));
-        if (!normalizedFile.startsWith(`${packagesRoot}/`)) {
+        const packages = this.getPackages();
+        if (!packages.some((item) => isPackageFile(item, normalizedFile))) {
             return false;
         }
-        if (normalizedFile.endsWith(aukletConfigFile))
+        if (isAukletConfigFile(path.basename(normalizedFile)))
             return true;
         if (SOURCE_MODULE_RE.test(normalizedFile))
             return true;
         return this.options.styleExtensions.some((extension) => normalizedFile.endsWith(extension));
     }
     async getWatchRoots() {
-        const packagesRoot = path.join(this.root, this.options.packagesDir);
-        return [
-            toWatchPath(packagesRoot, '*', 'src'),
-            toWatchPath(packagesRoot, '*', aukletConfigFile),
-        ];
+        return this.getPackages().flatMap((item) => [
+            toWatchPath(item.packageRoot, 'src'),
+            ...aukletConfigFiles.map((file) => toWatchPath(item.packageRoot, file)),
+        ]);
+    }
+    getWorkspacePackages() {
+        const readWorkspacePackages = this.options.readWorkspacePackages;
+        if (!readWorkspacePackages &&
+            !fs.existsSync(path.join(this.options.root, 'pnpm-workspace.yaml'))) {
+            return null;
+        }
+        try {
+            const readPackages = readWorkspacePackages ?? readPnpmWorkspacePackageInfoSync;
+            return readPackages(this.options.root)
+                .filter((item) => !this.isWorkspaceRootPackage(item))
+                .map((item) => ({
+                packageName: item.name,
+                packageRoot: normalizeFileKey(item.path),
+            }));
+        }
+        catch (error) {
+            throw new Error('[auklet:css] failed to read pnpm workspace packages for Vite monorepo mode.', { cause: error });
+        }
+    }
+    isWorkspaceRootPackage(item) {
+        const normalizedPackageRoot = normalizeFileKey(item.path);
+        const rawPackageRoot = toPosixPath(path.resolve(item.path));
+        return (normalizedPackageRoot === this.root || rawPackageRoot === this.rawRoot);
     }
 }
+const isPackageFile = (item, normalizedFile) => {
+    const packageRoot = normalizeFileKey(item.packageRoot);
+    return (normalizedFile === packageRoot ||
+        normalizedFile.startsWith(`${packageRoot}/`));
+};

package/dist/css/vite/moduleGraph/packageSource/singlePackage.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { aukletConfigFile, normalizeAukletConfig } from '#auklet/config';
+import { aukletConfigFiles, isAukletConfigFile, normalizeAukletConfig, } from '#auklet/config';
 import { loadAukletConfig } from '#auklet/configLoader';
 import { SOURCE_MODULE_RE } from '#auklet/css/constants';
 import { normalizeFileKey, toWatchPath } from '#auklet/utils';
@@ -27,7 +27,7 @@ export class SinglePackageSource {
         const normalizedFile = normalizeFileKey(file);
         if (!this.isInsidePackage(normalizedFile))
             return false;
-        if (normalizedFile.endsWith(aukletConfigFile))
+        if (isAukletConfigFile(path.basename(normalizedFile)))
             return true;
         if (SOURCE_MODULE_RE.test(normalizedFile))
             return true;
@@ -37,7 +37,7 @@ export class SinglePackageSource {
         const normalizedConfig = normalizeAukletConfig(await this.loadAukletConfig(this.root, { cacheBust: true }));
         return [
             toWatchPath(this.root, normalizedConfig.source),
-            toWatchPath(this.root, aukletConfigFile),
+            ...aukletConfigFiles.map((file) => toWatchPath(this.root, file)),
         ];
     }
     getPackageInfo() {

package/dist/css/vite/moduleGraph/requestCache.d.ts

@@ -9,7 +9,7 @@ export type PackageStyleContext = {
     context: ResolvedModuleStyleBuildContext;
     packageContext: StylePackageContext;
     packageName: string;
-    configPath: string;
+    configPaths: Array<string>;
     resolver: WorkspaceStyleResolver;
     sourceRoot: string;
     styleProcessor: StyleProcessor;
@@ -27,6 +27,9 @@ export declare class ModuleStyleGraphRequestCache {
     getPackageNames(): string[];
     isKnownPackageName(packageName: string): boolean;
     getContext(parsed: PackageStyleId): Promise<PackageStyleContext | {
+        context: ResolvedModuleStyleBuildContext;
+        configPaths: string[];
+        packageContext: StylePackageContext;
         normalizedConfig: {
             source: string;
             output: string;
@@ -54,10 +57,7 @@ export declare class ModuleStyleGraphRequestCache {
                 };
             };
         };
-        context: ResolvedModuleStyleBuildContext;
-        packageContext: StylePackageContext;
         packageName: string;
-        configPath: string;
         resolver: WorkspaceStyleResolver;
         sourceRoot: string;
         styleProcessor: StyleProcessor;

package/dist/css/vite/moduleGraph/requestCache.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
-import { aukletConfigFile, normalizeAukletConfig } from '#auklet/config';
-import { loadAukletConfig } from '#auklet/configLoader';
+import { loadAukletConfig, resolveAukletConfigPath, } from '#auklet/configLoader';
+import { aukletConfigFiles, normalizeAukletConfig } from '#auklet/config';
 import { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 export class ModuleStyleGraphRequestCache {
     options;
@@ -31,6 +31,10 @@ export class ModuleStyleGraphRequestCache {
         if (!stylePackage)
             return null;
         const packageRoot = stylePackage.packageRoot;
+        const configPath = resolveAukletConfigPath(packageRoot);
+        const configPaths = configPath
+            ? [configPath]
+            : aukletConfigFiles.map((file) => path.join(packageRoot, file));
         const rawConfig = await this.loadAukletConfig(packageRoot, {
             cacheBust: true,
         });
@@ -46,11 +50,11 @@ export class ModuleStyleGraphRequestCache {
             normalizedConfig,
         });
         return {
-            normalizedConfig,
             context,
+            configPaths,
             packageContext,
+            normalizedConfig,
             packageName: parsed.packageName,
-            configPath: path.join(packageRoot, aukletConfigFile),
             resolver: packageContext.resolver,
             sourceRoot: packageContext.sourceRoot,
             styleProcessor: packageContext.styleProcessor,

package/dist/css/vite/moduleGraph/styleCodeFactory.js

@@ -53,7 +53,7 @@ export class StyleCodeFactory {
     async createDependencyStyleCode(context, cache, specifiers, mapSpecifier = (specifier) => specifier) {
         const results = [];
         const imports = [];
-        const watchFiles = [context.configPath];
+        const watchFiles = [...context.configPaths];
         for (const specifier of specifiers) {
             const outputSpecifier = mapSpecifier(specifier);
             const parsed = this.parsePackageStyleIdInRequest(outputSpecifier, cache);
@@ -83,7 +83,7 @@ export class StyleCodeFactory {
         const { themeFiles } = context.packageContext;
         const targetThemeNames = themeNames ?? context.packageContext.themeNames;
         const root = context.styleProcessor.createRoot();
-        const watchFiles = [context.configPath, ...themeFiles.values()];
+        const watchFiles = [...context.configPaths, ...themeFiles.values()];
         const dependencyResults = [];
         for (const themeName of targetThemeNames) {
             for (const part of createThemeEntryParts(context.normalizedConfig, themeName, {
@@ -122,7 +122,7 @@ export class StyleCodeFactory {
         }
         return {
             code: root.nodes?.length ? context.styleProcessor.stringify(root) : '',
-            watchFiles: [context.configPath, ...styleFiles],
+            watchFiles: [...context.configPaths, ...styleFiles],
         };
     }
     async createSourceModuleStyleCode(context, cache, stylePath) {
@@ -162,7 +162,7 @@ export class StyleCodeFactory {
                 .filter((code) => code.trim())
                 .join('\n'),
             watchFiles: [
-                context.configPath,
+                ...context.configPaths,
                 ...styleFiles,
                 ...moduleStyleWatchFiles,
                 ...sourceFiles.filter((file) => /\.(ts|tsx)$/.test(file)),

package/dist/css/vite/moduleGraph/types.d.ts

@@ -1,7 +1,6 @@
 import type { AukletConfig, ModuleStyleBuildConfig } from '#auklet/types';
 export interface ModuleStyleGraphOptions {
     root: string;
-    packagesDir?: string;
     mode?: 'monorepo' | 'package';
     config?: ModuleStyleBuildConfig;
     loadAukletConfig?: LoadAukletConfig;

package/dist/css/watch/watcher.d.ts

@@ -2,7 +2,6 @@ import type { ModuleStyleBuildConfig, ModuleStyleBuildContext } from '#auklet/ty
 export declare class ModuleStyleWatcher {
     private readonly config;
     private readonly context;
-    private readonly logger?;
     private timer;
     private isBuilding;
     private shouldRebuild;