auklet 0.0.14 → 0.0.16

package/bin/entry.cjs

@@ -45,9 +45,8 @@ const runBuildStyle = async (args, options = {}) => {
     return 0;
   }
 
-  const { ModuleStyleBuilder } = await import(
-    '../dist/css/production/builder.js'
-  );
+  const { ModuleStyleBuilder } =
+    await import('../dist/css/production/builder.js');
   const builder = new ModuleStyleBuilder({ aukletConfig, logger: console });
   await builder.build();
   return 0;
@@ -60,9 +59,8 @@ const runBuildJs = async (args) => {
 
 const runBuild = async (args) => {
   const aukletConfig = await loadCurrentAukletConfig();
-  const { cleanAukletOutputByConfig } = await import(
-    '../dist/build/cleanOutput.js'
-  );
+  const { cleanAukletOutputByConfig } =
+    await import('../dist/build/cleanOutput.js');
   cleanAukletOutputByConfig(process.cwd(), aukletConfig);
 
   const jsExitCode = await runBuildJs(args);

package/dist/build/tsdownConfig.d.ts

@@ -1,7 +1,3 @@
-export {
-  type TsdownFormat,
-  defineKernelPackageConfigFromFile,
-  defineKernelPackageConfigFromOptions,
-} from '#auklet/build/tsdown/define';
-declare const _default: Promise<import('tsdown/config').UserConfig[]>;
+export { type TsdownFormat, defineKernelPackageConfigFromFile, defineKernelPackageConfigFromOptions, } from '#auklet/build/tsdown/define';
+declare const _default: Promise<import("tsdown/config").UserConfig[]>;
 export default _default;

package/dist/css/core/styleProcessor.d.ts

@@ -2,15 +2,16 @@ import postcss, { type Root } from 'postcss';
 import type { ModuleStyleBuildConfig } from '#auklet/types';
 import type { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
 export declare class StyleProcessor {
-  private readonly config;
-  private readonly resolver;
-  constructor(config: ModuleStyleBuildConfig, resolver: WorkspaceStyleResolver);
-  createRoot(): postcss.Root;
-  appendImportRule(root: Root, specifier: string): void;
-  stringify(root: Root): string;
-  appendStyleContent(target: Root, content: string, from: string): void;
-  readStyleFile(stylePath: string, seen?: Set<string>): string;
-  collectImportedStyleFiles(styleFiles: Array<string>): Set<string>;
-  private parse;
-  private parseImportSpecifier;
+    private readonly config;
+    private readonly resolver;
+    constructor(config: ModuleStyleBuildConfig, resolver: WorkspaceStyleResolver);
+    createRoot(): postcss.Root;
+    appendImportRule(root: Root, specifier: string): void;
+    stringify(root: Root): string;
+    appendStyleContent(target: Root, content: string, from: string): void;
+    readStyleFile(stylePath: string, seen?: Set<string>): string;
+    collectImportedStyleFiles(styleFiles: Array<string>): Set<string>;
+    collectStyleImportSpecifiers(styleFiles: Array<string>): Set<string>;
+    private parse;
+    private parseImportSpecifier;
 }

package/dist/css/core/styleProcessor.js

@@ -78,6 +78,18 @@ export class StyleProcessor {
     }
     return imported;
   }
+  collectStyleImportSpecifiers(styleFiles) {
+    const specifiers = new Set();
+    for (const styleFile of styleFiles) {
+      const css = fs.readFileSync(styleFile, 'utf8');
+      const root = this.parse(css, styleFile);
+      root.walkAtRules('import', (rule) => {
+        const specifier = this.parseImportSpecifier(rule.params);
+        if (specifier) specifiers.add(specifier);
+      });
+    }
+    return specifiers;
+  }
   parse(code, from) {
     // Keep parsing behind one method so future style languages can transform
     // to CSS before PostCSS reads the final stylesheet.

package/dist/css/production/format/componentWriter.d.ts

@@ -1,12 +1,12 @@
 import type { ModuleStyleEntryPlan } from '#auklet/css/core/styleModuleEntryPlanner';
 import { type FormatWriterOptions } from '#auklet/css/production/format/shared';
 export declare class ComponentStyleEntryWriter {
-  private readonly config;
-  private readonly sourceRoot;
-  private readonly resolver;
-  private readonly styleProcessor;
-  constructor(options: FormatWriterOptions);
-  write(outRoot: string, entries: Array<ModuleStyleEntryPlan>): string[];
-  private getModuleStyleSpecifiers;
-  private getOwnStyleSpecifiers;
+    private readonly config;
+    private readonly sourceRoot;
+    private readonly resolver;
+    private readonly styleProcessor;
+    constructor(options: FormatWriterOptions);
+    write(outRoot: string, entries: Array<ModuleStyleEntryPlan>): string[];
+    private getModuleStyleSpecifiers;
+    private getOwnStyleSpecifiers;
 }

package/dist/css/production/format/componentWriter.js

@@ -21,8 +21,16 @@ export class ComponentStyleEntryWriter {
         this.config.output.styleDir,
       );
       const target = path.join(styleDir, this.config.output.indexStyleFile);
+      const ownImports = this.styleProcessor.collectStyleImportSpecifiers(
+        entry.ownStyleFiles,
+      );
       const sourceStyleSpecifiers = [
-        ...this.getModuleStyleSpecifiers(entry.moduleStyleImports, styleDir),
+        ...this.getModuleStyleSpecifiers(
+          entry.moduleStyleImports.filter(
+            (specifier) => !ownImports.has(specifier),
+          ),
+          styleDir,
+        ),
         ...this.getOwnStyleSpecifiers(entry.ownStyleFiles, styleDir, outRoot),
       ];
       const root = this.styleProcessor.createRoot();

package/dist/css/production/format/entryWriter.d.ts

@@ -1,12 +1,8 @@
 import { type FormatWriterOptions } from '#auklet/css/production/format/shared';
 export declare class StyleEntryWriter {
-  private readonly config;
-  private readonly packageContext;
-  private readonly styleProcessor;
-  constructor(options: FormatWriterOptions);
-  write(
-    outRoot: string,
-    themeStyles: Map<string, string>,
-    moduleStyle: string | null,
-  ): string | null;
+    private readonly config;
+    private readonly packageContext;
+    private readonly styleProcessor;
+    constructor(options: FormatWriterOptions);
+    write(outRoot: string, themeStyles: Map<string, string>, moduleStyle: string | null): string | null;
 }

package/dist/css/production/format/externalWriter.d.ts

@@ -1,9 +1,9 @@
 import { type FormatWriterOptions } from '#auklet/css/production/format/shared';
 export declare class ExternalStyleWriter {
-  private readonly config;
-  private readonly packageContext;
-  private readonly resolver;
-  private readonly styleProcessor;
-  constructor(options: FormatWriterOptions);
-  write(outRoot: string): string;
+    private readonly config;
+    private readonly packageContext;
+    private readonly resolver;
+    private readonly styleProcessor;
+    constructor(options: FormatWriterOptions);
+    write(outRoot: string): string;
 }

package/dist/css/production/format/moduleWriter.d.ts

@@ -1,8 +1,8 @@
 import { type FormatWriterOptions } from '#auklet/css/production/format/shared';
 export declare class ModuleStyleWriter {
-  private readonly config;
-  private readonly packageContext;
-  private readonly styleProcessor;
-  constructor(options: FormatWriterOptions);
-  write(outRoot: string): string | null;
+    private readonly config;
+    private readonly packageContext;
+    private readonly styleProcessor;
+    constructor(options: FormatWriterOptions);
+    write(outRoot: string): string | null;
 }

package/dist/css/production/format/sourceWriter.d.ts

@@ -1,6 +1,6 @@
 import { type FormatWriterOptions } from '#auklet/css/production/format/shared';
 export declare class SourceStyleFileWriter {
-  private readonly sourceRoot;
-  constructor(options: FormatWriterOptions);
-  copy(files: Array<string>, outRoot: string): void;
+    private readonly sourceRoot;
+    constructor(options: FormatWriterOptions);
+    copy(files: Array<string>, outRoot: string): void;
 }

package/dist/css/production/format/themeWriter.d.ts

@@ -1,16 +1,10 @@
-import {
-  type FormatWriterOptions,
-  type ThemeStyleOutput,
-} from '#auklet/css/production/format/shared';
+import { type FormatWriterOptions, type ThemeStyleOutput } from '#auklet/css/production/format/shared';
 export declare class ThemeStyleWriter {
-  private readonly config;
-  private readonly packageContext;
-  private readonly styleProcessor;
-  constructor(options: FormatWriterOptions);
-  clean(outRoot: string): void;
-  writeThemeStyles(outRoot: string): ThemeStyleOutput[];
-  writeThemeEntries(
-    themeStyles: Map<string, string>,
-    outRoot: string,
-  ): string[];
+    private readonly config;
+    private readonly packageContext;
+    private readonly styleProcessor;
+    constructor(options: FormatWriterOptions);
+    clean(outRoot: string): void;
+    writeThemeStyles(outRoot: string): ThemeStyleOutput[];
+    writeThemeEntries(themeStyles: Map<string, string>, outRoot: string): string[];
 }

package/dist/css/vite/hmr.js

@@ -18,7 +18,7 @@ const getRelativeFile = (file) => {
 };
 const invalidateVirtualModules = (server, graph) => {
   const modules = [];
-  for (const packageName of graph.getWorkspacePackageNames()) {
+  for (const packageName of graph.getPackageNames()) {
     for (const entry of ['style.css', 'external.css', 'module.css']) {
       const module = server.moduleGraph.getModuleById(
         `\0auklet-css:${packageName}/${entry}`,
@@ -77,7 +77,7 @@ export class AukletStyleHmr {
   handleStyleHotUpdate(context) {
     const graph = this.graph();
     if (
-      !graph.isWorkspaceSourceGraphFile(context.file) ||
+      !graph.isSourceGraphFile(context.file) ||
       !graph.isStyleFile(context.file)
     ) {
       return;

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

@@ -4,8 +4,7 @@ import type {
 } from '#auklet/css/vite/moduleGraph/types';
 export declare class ModuleStyleGraph {
   private readonly config;
-  private readonly workspaceRoot;
-  private readonly packagesDir;
+  private readonly packageSource;
   private readonly styleCodeFactory;
   private readonly loadAukletConfig;
   constructor(options: ModuleStyleGraphOptions);
@@ -13,10 +12,10 @@ export declare class ModuleStyleGraph {
     packageName: string;
     stylePath: string;
   } | null;
-  isWorkspaceSourceGraphFile(file: string): boolean;
+  isSourceGraphFile(file: string): boolean;
   isStyleConfigFile(file: string): boolean;
   isStyleFile(file: string): boolean;
-  getWorkspacePackageNames(): string[];
+  getPackageNames(): string[];
   getWatchRoots(): string[];
   createPackageStyleCode(parsed: PackageStyleId): Promise<{
     code: string;

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

@@ -2,43 +2,36 @@ import path from 'node:path';
 import { aukletConfigFile } from '#auklet/config';
 import { loadAukletConfig } from '#auklet/configLoader';
 import { moduleStyleBuildConfig } from '#auklet/css/config';
-import { ModuleStyleGraphRequestCache } from '#auklet/css/vite/moduleGraph/requestCache';
-import { StyleCodeFactory } from '#auklet/css/vite/moduleGraph/styleCodeFactory';
 import { parsePackageStyleId } from '#auklet/css/vite/moduleGraph/styleId';
-import { SOURCE_COMPONENT_MODULE_RE } from '#auklet/css/constants';
-import { normalizeFileKey, toWatchPath } from '#auklet/utils';
-// package style graph 的对外门面，负责 workspace 发现、watch 边界和请求分发。
+import { StyleCodeFactory } from '#auklet/css/vite/moduleGraph/styleCodeFactory';
+import { ModuleStyleGraphRequestCache } from '#auklet/css/vite/moduleGraph/requestCache';
+import { createMonorepoPackageSource } from '#auklet/css/vite/moduleGraph/packageSource/monorepo';
+import { normalizeFileKey } from '#auklet/utils';
+// package style graph 的对外门面，负责 package source、watch 边界和请求分发。
 export class ModuleStyleGraph {
   config;
-  workspaceRoot;
-  packagesDir;
+  packageSource;
   styleCodeFactory;
   loadAukletConfig;
   constructor(options) {
     this.config = options.config ?? moduleStyleBuildConfig;
-    this.workspaceRoot = normalizeFileKey(options.workspaceRoot);
-    this.packagesDir = options.packagesDir ?? 'packages';
+    const mode = options.mode ?? 'monorepo';
+    if (mode === 'package') {
+      throw new Error('[auklet:css] package mode is not supported yet.');
+    }
+    this.packageSource = createMonorepoPackageSource({
+      workspaceRoot: normalizeFileKey(options.workspaceRoot),
+      packagesDir: options.packagesDir ?? 'packages',
+      styleExtensions: this.config.styleExtensions,
+    });
     this.loadAukletConfig = options.loadAukletConfig ?? loadAukletConfig;
     this.styleCodeFactory = new StyleCodeFactory(this.config);
   }
   parsePackageStyleId(id) {
-    return parsePackageStyleId(id, this.getWorkspacePackageNames());
+    return parsePackageStyleId(id, this.getPackageNames());
   }
-  isWorkspaceSourceGraphFile(file) {
-    const normalizedFile = normalizeFileKey(file);
-    const packagesRoot = normalizeFileKey(
-      path.join(this.workspaceRoot, this.packagesDir),
-    );
-    if (!normalizedFile.startsWith(`${packagesRoot}/`)) {
-      return false;
-    }
-    if (normalizedFile.endsWith(aukletConfigFile)) return true;
-    if (SOURCE_COMPONENT_MODULE_RE.test(normalizedFile)) {
-      return true;
-    }
-    return this.config.styleExtensions.some((extension) =>
-      normalizedFile.endsWith(extension),
-    );
+  isSourceGraphFile(file) {
+    return this.packageSource.isSourceGraphFile(file);
   }
   isStyleConfigFile(file) {
     return normalizeFileKey(file).endsWith(aukletConfigFile);
@@ -46,15 +39,11 @@ export class ModuleStyleGraph {
   isStyleFile(file) {
     return this.config.styleExtensions.includes(path.extname(file));
   }
-  getWorkspacePackageNames() {
-    return this.createRequestCache().getWorkspacePackageNames();
+  getPackageNames() {
+    return this.packageSource.getPackageNames();
   }
   getWatchRoots() {
-    const packagesRoot = path.join(this.workspaceRoot, this.packagesDir);
-    return [
-      toWatchPath(packagesRoot, '*', 'src'),
-      toWatchPath(packagesRoot, '*', aukletConfigFile),
-    ];
+    return this.packageSource.getWatchRoots();
   }
   createPackageStyleCode(parsed) {
     return this.styleCodeFactory.createPackageStyleCode(
@@ -64,8 +53,7 @@ export class ModuleStyleGraph {
   }
   createRequestCache() {
     return new ModuleStyleGraphRequestCache({
-      workspaceRoot: this.workspaceRoot,
-      packagesDir: this.packagesDir,
+      packageSource: this.packageSource,
       config: this.config,
       loadAukletConfig: this.loadAukletConfig,
     });

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

@@ -0,0 +1,9 @@
+import type { StylePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/types';
+export type MonorepoPackageSourceOptions = {
+  workspaceRoot: string;
+  packagesDir: string;
+  styleExtensions: Array<string>;
+};
+export declare function createMonorepoPackageSource(
+  options: MonorepoPackageSourceOptions,
+): StylePackageSource;

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

@@ -0,0 +1,77 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { aukletConfigFile } from '#auklet/config';
+import { SOURCE_COMPONENT_MODULE_RE } from '#auklet/css/constants';
+import { normalizeFileKey, toWatchPath } from '#auklet/utils';
+export function createMonorepoPackageSource(options) {
+  return new MonorepoPackageSource(options);
+}
+class MonorepoPackageSource {
+  options;
+  packages;
+  packageNames;
+  workspaceRoot;
+  constructor(options) {
+    this.options = options;
+    this.workspaceRoot = normalizeFileKey(options.workspaceRoot);
+  }
+  getPackages() {
+    if (this.packages) return this.packages;
+    const packagesRoot = path.join(
+      this.workspaceRoot,
+      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,
+          },
+        ];
+      });
+    return this.packages;
+  }
+  getPackageNames() {
+    this.packageNames ??= this.getPackages().map((item) => item.packageName);
+    return this.packageNames;
+  }
+  isKnownPackageName(packageName) {
+    return this.getPackageNames().includes(packageName);
+  }
+  isSourceGraphFile(file) {
+    const normalizedFile = normalizeFileKey(file);
+    const packagesRoot = normalizeFileKey(
+      path.join(this.workspaceRoot, this.options.packagesDir),
+    );
+    if (!normalizedFile.startsWith(`${packagesRoot}/`)) {
+      return false;
+    }
+    if (normalizedFile.endsWith(aukletConfigFile)) return true;
+    if (SOURCE_COMPONENT_MODULE_RE.test(normalizedFile)) return true;
+    return this.options.styleExtensions.some((extension) =>
+      normalizedFile.endsWith(extension),
+    );
+  }
+  getWatchRoots() {
+    const packagesRoot = path.join(
+      this.workspaceRoot,
+      this.options.packagesDir,
+    );
+    return [
+      toWatchPath(packagesRoot, '*', 'src'),
+      toWatchPath(packagesRoot, '*', aukletConfigFile),
+    ];
+  }
+}

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

@@ -0,0 +1,11 @@
+export type StylePackageInfo = {
+  packageName: string;
+  packageRoot: string;
+};
+export interface StylePackageSource {
+  getPackages(): Array<StylePackageInfo>;
+  getPackageNames(): Array<string>;
+  isKnownPackageName(packageName: string): boolean;
+  isSourceGraphFile(file: string): boolean;
+  getWatchRoots(): Array<string>;
+}

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

@@ -6,6 +6,7 @@ import type {
 } from '#auklet/types';
 import type { StyleProcessor } from '#auklet/css/core/styleProcessor';
 import type { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
+import type { StylePackageSource } from '#auklet/css/vite/moduleGraph/packageSource/types';
 import type {
   LoadAukletConfig,
   PackageStyleId,
@@ -21,20 +22,17 @@ export type PackageStyleContext = {
   styleProcessor: StyleProcessor;
 };
 export type ModuleStyleGraphRequestCacheOptions = {
-  workspaceRoot: string;
-  packagesDir: string;
+  packageSource: StylePackageSource;
   config: ModuleStyleBuildConfig;
   loadAukletConfig?: LoadAukletConfig;
 };
 export declare class ModuleStyleGraphRequestCache {
   private readonly options;
-  private workspacePackages?;
-  private workspacePackageNames?;
   private readonly contexts;
   private readonly loadAukletConfig;
   constructor(options: ModuleStyleGraphRequestCacheOptions);
-  getWorkspacePackageNames(): string[];
-  isWorkspacePackageName(packageName: string): boolean;
+  getPackageNames(): string[];
+  isKnownPackageName(packageName: string): boolean;
   getContext(parsed: PackageStyleId): Promise<
     | PackageStyleContext
     | {
@@ -76,5 +74,4 @@ export declare class ModuleStyleGraphRequestCache {
     | null
   >;
   private createContext;
-  private getWorkspacePackages;
 }

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

@@ -1,26 +1,20 @@
-import fs from 'node:fs';
 import path from 'node:path';
 import { aukletConfigFile, normalizeAukletConfig } from '#auklet/config';
 import { loadAukletConfig } from '#auklet/configLoader';
 import { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 export class ModuleStyleGraphRequestCache {
   options;
-  workspacePackages;
-  workspacePackageNames;
   contexts = new Map();
   loadAukletConfig;
   constructor(options) {
     this.options = options;
     this.loadAukletConfig = options.loadAukletConfig ?? loadAukletConfig;
   }
-  getWorkspacePackageNames() {
-    this.workspacePackageNames ??= this.getWorkspacePackages().map(
-      (item) => item.packageName,
-    );
-    return this.workspacePackageNames;
+  getPackageNames() {
+    return this.options.packageSource.getPackageNames();
   }
-  isWorkspacePackageName(packageName) {
-    return this.getWorkspacePackageNames().includes(packageName);
+  isKnownPackageName(packageName) {
+    return this.options.packageSource.isKnownPackageName(packageName);
   }
   async getContext(parsed) {
     const cachedContext = this.contexts.get(parsed.packageName);
@@ -30,12 +24,11 @@ export class ModuleStyleGraphRequestCache {
     return context;
   }
   async createContext(parsed) {
-    const workspacePackage = this.getWorkspacePackages().find(
-      (item) => item.packageName === parsed.packageName,
-    );
-    if (!workspacePackage) return null;
-    const packageRoot = workspacePackage.packageRoot;
-    if (!fs.existsSync(packageRoot)) return null;
+    const stylePackage = this.options.packageSource
+      .getPackages()
+      .find((item) => item.packageName === parsed.packageName);
+    if (!stylePackage) return null;
+    const packageRoot = stylePackage.packageRoot;
     const rawConfig = await this.loadAukletConfig(packageRoot, {
       cacheBust: true,
     });
@@ -61,32 +54,4 @@ export class ModuleStyleGraphRequestCache {
       styleProcessor: packageContext.styleProcessor,
     };
   }
-  getWorkspacePackages() {
-    if (this.workspacePackages) return this.workspacePackages;
-    const packagesRoot = path.join(
-      this.options.workspaceRoot,
-      this.options.packagesDir,
-    );
-    if (!fs.existsSync(packagesRoot)) {
-      this.workspacePackages = [];
-      return this.workspacePackages;
-    }
-    this.workspacePackages = 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,
-          },
-        ];
-      });
-    return this.workspacePackages;
-  }
 }

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

@@ -263,7 +263,7 @@ export class StyleCodeFactory {
   toDevExternalStyleSpecifier(specifier, cache) {
     const parsed = parsePackageStyleSpecifier(specifier);
     if (!parsed) return specifier;
-    if (cache.isWorkspacePackageName(parsed.packageName)) {
+    if (cache.isKnownPackageName(parsed.packageName)) {
       if (parsed.stylePath === STYLE_ENTRY) {
         return `${parsed.packageName}/${EXTERNAL_ENTRY}`;
       }
@@ -279,6 +279,6 @@ export class StyleCodeFactory {
     return specifier;
   }
   parsePackageStyleIdInRequest(id, cache) {
-    return parsePackageStyleId(id, cache.getWorkspacePackageNames());
+    return parsePackageStyleId(id, cache.getPackageNames());
   }
 }

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

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

package/dist/css/vite/vitePlugin.d.ts

@@ -1,7 +1,7 @@
 import type { HotUpdateOptions, ViteDevServer } from 'vite';
 import type { ModuleStyleGraphOptions } from '#auklet/css/vite/moduleGraph/types';
 export type AukletStylePluginOptions = Partial<
-  Pick<ModuleStyleGraphOptions, 'workspaceRoot'>
+  Pick<ModuleStyleGraphOptions, 'workspaceRoot' | 'mode'>
 > &
   Omit<ModuleStyleGraphOptions, 'workspaceRoot'>;
 export declare function aukletStylePlugin(options?: AukletStylePluginOptions): {

package/dist/css/vite/vitePlugin.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { ModuleStyleGraph } from '#auklet/css/vite/moduleGraph/graph';
 import { AukletStyleHmr } from '#auklet/css/vite/hmr';
+import { ModuleStyleGraph } from '#auklet/css/vite/moduleGraph/graph';
 const WORKSPACE_FILE = 'pnpm-workspace.yaml';
 const VIRTUAL_ID_PREFIX = 'virtual:auklet-css:';
 const RESOLVED_VIRTUAL_ID_PREFIX = '\0auklet-css:';
@@ -39,7 +39,7 @@ const createModuleStyleGraph = (options, viteRoot) => {
 };
 const invalidateVirtualModules = (server, graph) => {
   const modules = [];
-  for (const packageName of graph.getWorkspacePackageNames()) {
+  for (const packageName of graph.getPackageNames()) {
     for (const entry of ['style.css', 'external.css', 'module.css']) {
       const module = server.moduleGraph.getModuleById(
         `${RESOLVED_VIRTUAL_ID_PREFIX}${packageName}/${entry}`,
@@ -98,7 +98,7 @@ export function aukletStylePlugin(options = {}) {
       hmr.installFullReloadGuard(server);
       server.watcher.add(graph.getWatchRoots());
       const invalidateStyleGraph = (file) => {
-        if (!graph.isWorkspaceSourceGraphFile(file)) return false;
+        if (!graph.isSourceGraphFile(file)) return false;
         invalidateVirtualModules(server, graph);
         return true;
       };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "type": "module",
   "author": "chentao.arthur",
   "packageManager": "pnpm@10.27.0",
@@ -20,6 +20,7 @@
     "test:examples": "pnpm build:examples && vitest run examples/__tests__",
     "test:coverage": "vitest run src/__tests__ --coverage",
     "typecheck": "tsc --noEmit --skipLibCheck",
+    "dev:examples": "pnpm --filter './examples/*' --if-present dev",
     "build:examples": "pnpm --filter './examples/*' build",
     "format:md": "prettier --write \"*.md\" \"examples/**/*.md\"",
     "format": "prettier --write \"package.json\" \"pnpm-workspace.yaml\" \"(bin|src|dist|examples)/**/*.{js,mjs,cjs,ts,tsx,json,md,yaml,css}\""
@@ -63,26 +64,26 @@
     "tsdown"
   ],
   "dependencies": {
-    "unrun": "^0.3.0",
-    "execa": "^9.1.0",
-    "aidly": "^1.37.0",
-    "rimraf": "^6.0.1",
-    "tsdown": "^0.22.0",
-    "postcss": "^8.5.14",
-    "chokidar": "^5.0.0",
-    "minimist": "^1.2.8",
-    "typescript": "^6.0.3",
-    "conditional-export": "^1.1.0"
+    "unrun": "catalog:",
+    "execa": "catalog:",
+    "aidly": "catalog:",
+    "rimraf": "catalog:",
+    "tsdown": "catalog:",
+    "postcss": "catalog:",
+    "chokidar": "catalog:",
+    "minimist": "catalog:",
+    "typescript": "catalog:",
+    "conditional-export": "catalog:"
   },
   "devDependencies": {
-    "@types/node": "^22.17.0",
-    "@types/minimist": "^1.2.5",
-    "@vitest/coverage-v8": "^1.6.0",
-    "husky": "^9.0.11",
-    "prettier": "^2.4.1",
-    "lint-staged": "^15.2.5",
-    "vite": "^8.0.13",
-    "vitest": "^1.6.0"
+    "@types/node": "catalog:",
+    "@types/minimist": "catalog:",
+    "@vitest/coverage-v8": "catalog:",
+    "husky": "catalog:",
+    "prettier": "catalog:",
+    "lint-staged": "catalog:",
+    "vite": "catalog:",
+    "vitest": "catalog:"
   },
   "lint-staged": {
     "*.js": [