auklet 0.1.9 → 0.2.1

package/dist/configLoader.js

@@ -6,6 +6,7 @@ import { aukletConfigFiles, isAukletConfigFile } from '#auklet/config';
 const asRecord = (value) => {
     return isPlainObject(value) ? value : null;
 };
+let configImportVersion = 0;
 const assertSupportedConfigFile = (configFile) => {
     const basename = path.basename(configFile);
     if (isAukletConfigFile(basename))
@@ -53,7 +54,8 @@ export async function loadAukletConfig(packageRoot, options = {}) {
     }
     const url = pathToFileURL(configPath);
     if (options.cacheBust) {
-        url.searchParams.set('t', Date.now().toString());
+        configImportVersion += 1;
+        url.searchParams.set('t', configImportVersion.toString());
     }
     const module = (await import(url.href));
     return resolveAukletConfigModule(module);

package/dist/css/core/style/entries.js

@@ -1,5 +1,4 @@
 import { getGlobalStyleDependencies, getThemeNames, getThemeStyleDependencies, } from '#auklet/css/core/style/dependencies';
-import { StyleModuleEntryPlanner } from '#auklet/css/core/styleModuleEntryPlanner';
 const dependenciesPart = (specifiers) => ({ type: 'dependencies', specifiers });
 // 环境无关的 style entry graph。production writer 和 Vite/dev renderer 都从这里取入口语义。
 export function createStyleEntryParts(config) {
@@ -25,11 +24,15 @@ export function createExternalEntryParts(config) {
     ];
 }
 export function collectModuleStyleImports(packageContext) {
-    return packageContext.importCollector.collect(packageContext.sourceFiles, packageContext.normalizedConfig);
+    return packageContext.getModuleStyleImports();
 }
 export function createModuleStyleEntryPlan(packageContext, sourceDir) {
-    return new StyleModuleEntryPlanner(packageContext).createEntry(sourceDir, collectModuleStyleImports(packageContext));
+    return packageContext
+        .getModuleStyleEntryPlanner()
+        .createEntry(sourceDir, collectModuleStyleImports(packageContext));
 }
 export function createModuleStyleEntryPlans(packageContext) {
-    return new StyleModuleEntryPlanner(packageContext).createEntries(collectModuleStyleImports(packageContext));
+    return packageContext
+        .getModuleStyleEntryPlanner()
+        .createEntries(collectModuleStyleImports(packageContext));
 }

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

@@ -1,4 +1,5 @@
 import { ModuleStyleImportCollector } from '#auklet/css/core/styleImports/collector';
+import { StyleModuleEntryPlanner } from '#auklet/css/core/styleModuleEntryPlanner';
 import { StyleProcessor } from '#auklet/css/core/styleProcessor';
 import { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
 import type { ModuleStyleBuildConfig, NormalizedAukletConfig, ResolvedModuleStyleBuildContext } from '#auklet/types';
@@ -18,6 +19,10 @@ export declare class StylePackageContext {
     readonly themeFiles: Map<string, string>;
     readonly themeNames: Array<string>;
     readonly styleFiles: Array<string>;
+    private moduleStyleEntryPlanner?;
+    private moduleStyleImports?;
     constructor(options: StylePackageContextOptions);
     getStyleFiles(files: Array<string>): string[];
+    getModuleStyleImports(): Map<string, string[]>;
+    getModuleStyleEntryPlanner(): StyleModuleEntryPlanner;
 }

package/dist/css/core/stylePackageContext.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { ModuleStyleImportCollector } from '#auklet/css/core/styleImports/collector';
+import { StyleModuleEntryPlanner } from '#auklet/css/core/styleModuleEntryPlanner';
 import { StyleProcessor } from '#auklet/css/core/styleProcessor';
 import { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
 import { createStyleFileKeySet } from '#auklet/css/core/style/files';
@@ -17,6 +18,8 @@ export class StylePackageContext {
     themeFiles;
     themeNames;
     styleFiles;
+    moduleStyleEntryPlanner;
+    moduleStyleImports;
     constructor(options) {
         this.options = options;
         const { config, context, normalizedConfig } = this.options;
@@ -38,4 +41,12 @@ export class StylePackageContext {
             .filter((file) => this.options.config.styleExtensions.includes(path.extname(file)))
             .filter((styleFile) => !themeFileKeys.has(normalizeFileKey(styleFile)));
     }
+    getModuleStyleImports() {
+        this.moduleStyleImports ??= this.importCollector.collect(this.sourceFiles, this.normalizedConfig);
+        return this.moduleStyleImports;
+    }
+    getModuleStyleEntryPlanner() {
+        this.moduleStyleEntryPlanner ??= new StyleModuleEntryPlanner(this);
+        return this.moduleStyleEntryPlanner;
+    }
 }

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

@@ -9,6 +9,8 @@ export declare class AukletStyleHmr {
     trackVirtualStyleDependency(file: string, virtualId: string): void;
     installFullReloadGuard(server: Pick<ViteDevServer, 'ws'>): void;
     handleStyleHotUpdate(context: HotUpdateOptions): never[] | undefined;
+    handleSourceModuleChange(server: Pick<ViteDevServer, 'moduleGraph' | 'ws'>, file: string): boolean;
+    private sendVirtualStyleUpdates;
     private suppressFullReload;
     private shouldSuppressFullReload;
     private isDuplicateUpdate;

package/dist/css/vite/hmr.js

@@ -26,6 +26,19 @@ const getDependencyVirtualModules = (virtualIdsByDependency, server, file) => {
         return module ? [module] : [];
     });
 };
+const createJsUpdates = (virtualIds, timestamp) => {
+    return virtualIds.map((id) => {
+        const browserPath = toBrowserVirtualPath(id);
+        return {
+            type: 'js-update',
+            path: browserPath,
+            acceptedPath: browserPath,
+            timestamp,
+            explicitImportRequired: false,
+            isWithinCircularImport: false,
+        };
+    });
+};
 export class AukletStyleHmr {
     graph;
     lastUpdateTimes = new Map();
@@ -64,30 +77,37 @@ export class AukletStyleHmr {
         if (this.isDuplicateUpdate(context.file)) {
             return [];
         }
-        const virtualIds = getDependencyVirtualIds(this.virtualIdsByDependency, context.file);
-        const modules = getDependencyVirtualModules(this.virtualIdsByDependency, context.server, context.file);
+        const updates = this.sendVirtualStyleUpdates(context.file, context.server, context.timestamp);
+        logger.info(`package css hmr ${getRelativeFile(context.file)} tracked=${updates.tracked} updates=${updates.sent}`);
+        return [];
+    }
+    handleSourceModuleChange(server, file) {
+        const graph = this.graph();
+        if (!graph.isSourceGraphFile(file) || !graph.isSourceModuleFile(file)) {
+            return false;
+        }
+        graph.invalidateFile(file);
+        const updates = this.sendVirtualStyleUpdates(file, server, Date.now());
+        logger.info(`package css source hmr ${getRelativeFile(file)} tracked=${updates.tracked} updates=${updates.sent}`);
+        return true;
+    }
+    sendVirtualStyleUpdates(file, server, timestamp) {
+        const virtualIds = getDependencyVirtualIds(this.virtualIdsByDependency, file);
+        const modules = getDependencyVirtualModules(this.virtualIdsByDependency, server, file);
         for (const module of modules) {
-            context.server.moduleGraph.invalidateModule(module);
+            server.moduleGraph.invalidateModule(module);
         }
-        const updates = virtualIds.map((id) => {
-            const browserPath = toBrowserVirtualPath(id);
-            return {
-                type: 'js-update',
-                path: browserPath,
-                acceptedPath: browserPath,
-                timestamp: context.timestamp,
-                explicitImportRequired: false,
-                isWithinCircularImport: false,
-            };
-        });
-        logger.info(`package css hmr ${getRelativeFile(context.file)} tracked=${virtualIds.length} updates=${updates.length}`);
+        const updates = createJsUpdates(virtualIds, timestamp);
         if (updates.length) {
-            context.server.ws.send({
+            server.ws.send({
                 type: 'update',
                 updates,
             });
         }
-        return [];
+        return {
+            sent: updates.length,
+            tracked: virtualIds.length,
+        };
     }
     suppressFullReload() {
         this.suppressFullReloadUntil = Date.now() + FULL_RELOAD_SUPPRESS_MS;

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

@@ -1,8 +1,10 @@
 import type { PackageStyleContext } from '#auklet/css/vite/moduleGraph/requestCache';
 export declare function toDevDependencyImportSpecifier(context: PackageStyleContext, specifier: string): {
     specifier: string;
+    cacheInputFiles?: undefined;
     watchFile?: undefined;
 } | {
+    cacheInputFiles: string[];
     specifier: string;
     watchFile: string;
 };

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

@@ -1,11 +1,62 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { toFsSpecifier } from '#auklet/utils';
+const getPackageName = (specifier) => {
+    if (!specifier.startsWith('@'))
+        return specifier.split('/')[0] ?? specifier;
+    const [scope, name] = specifier.split('/');
+    if (!scope || !name)
+        return null;
+    return `${scope}/${name}`;
+};
+const findNodeModulesPackageRoot = (file, packageName) => {
+    const resolved = path.resolve(file);
+    const root = path.parse(resolved).root;
+    const parts = path.relative(root, resolved).split(path.sep);
+    const packageParts = packageName.split('/');
+    const packageLength = packageParts.length;
+    for (let index = parts.length - packageLength - 1; index >= 0; index -= 1) {
+        if (parts[index] !== 'node_modules')
+            continue;
+        const candidateParts = parts.slice(index + 1, index + 1 + packageLength);
+        if (candidateParts.join('/') !== packageName)
+            continue;
+        return path.join(root, ...parts.slice(0, index + 1 + packageLength));
+    }
+    return null;
+};
+const findPackageJson = (file, context, specifier) => {
+    const packageName = getPackageName(specifier);
+    if (!packageName)
+        return null;
+    const packageRoot = findNodeModulesPackageRoot(file, packageName);
+    if (!packageRoot) {
+        return path.join(context.context.packageRoot, 'node_modules', packageName, 'package.json');
+    }
+    let current = path.dirname(file);
+    let next = current;
+    const packageRootKey = path.resolve(packageRoot);
+    do {
+        const packageJson = path.join(current, 'package.json');
+        if (fs.existsSync(packageJson))
+            return packageJson;
+        if (path.resolve(current) === packageRootKey)
+            break;
+        next = path.dirname(current);
+        if (next !== current)
+            current = next;
+    } while (next !== current);
+    return path.join(context.context.packageRoot, 'node_modules', packageName, 'package.json');
+};
 // 在 Vite 虚拟 CSS 中，第三方 CSS 依赖要用声明它的包作为解析根。
 export function toDevDependencyImportSpecifier(context, specifier) {
     if (specifier.startsWith('.') || specifier.startsWith('/')) {
         return { specifier };
     }
     const resolved = context.resolver.resolveStyleDependency(specifier);
+    const packageJson = findPackageJson(resolved, context, specifier);
     return {
+        cacheInputFiles: packageJson ? [packageJson] : [],
         specifier: toFsSpecifier(resolved),
         watchFile: resolved,
     };

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

@@ -15,10 +15,7 @@ export declare class ModuleStyleGraph {
     isStyleFile(file: string): boolean;
     getPackageNames(): string[];
     getWatchRoots(): Promise<string[]>;
-    createPackageStyleCode(parsed: PackageStyleId): Promise<{
-        code: string;
-        watchFiles: string[];
-    }>;
+    createPackageStyleCode(parsed: PackageStyleId): Promise<import("#auklet/css/vite/moduleGraph/types").PackageStyleLoadResult>;
     invalidatePackage(packageName: string): void;
     invalidateFile(file: string): string | null;
     isSourceModuleFile(file: string): boolean;

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

@@ -32,6 +32,8 @@ export class ModuleStyleGraph {
                     loadAukletConfig: this.loadAukletConfig,
                 });
         this.requestCache = new ModuleStyleGraphRequestCache({
+            root: normalizeFileKey(options.root),
+            mode: options.mode ?? 'package',
             packageSource: this.packageSource,
             config: this.config,
             loadAukletConfig: this.loadAukletConfig,

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

@@ -2,4 +2,6 @@ import type { PackageStyleLoadResult } from '#auklet/css/vite/moduleGraph/types'
 export declare function mergeLoadResults(...results: Array<PackageStyleLoadResult>): {
     code: string;
     watchFiles: string[];
+    cacheInputFiles: string[];
+    dependencyPackages: string[];
 };

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

@@ -6,5 +6,7 @@ export function mergeLoadResults(...results) {
             .filter((code) => code.trim())
             .join('\n'),
         watchFiles: Array.from(new Set(results.flatMap((result) => result.watchFiles))),
+        cacheInputFiles: Array.from(new Set(results.flatMap((result) => result.cacheInputFiles ?? []))),
+        dependencyPackages: Array.from(new Set(results.flatMap((result) => result.dependencyPackages ?? []))),
     };
 }

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

@@ -0,0 +1,15 @@
+import type { PackageStyleLoadResult } from '#auklet/css/vite/moduleGraph/types';
+export type PersistentStyleGraphCacheOptions = {
+    root: string;
+};
+export declare class PersistentStyleGraphCache {
+    private static readonly cleanedRoots;
+    private readonly cacheRoot;
+    constructor(options: PersistentStyleGraphCacheOptions);
+    createKey(value: unknown): string;
+    read(key: string): PackageStyleLoadResult | null;
+    write(key: string, result: PackageStyleLoadResult, inputFiles: Array<string>): void;
+    private cleanupStaleEntries;
+    private getCacheFile;
+    private isFresh;
+}

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

@@ -0,0 +1,179 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { toPosixPath } from '#auklet/utils';
+const cacheVersion = 'v1';
+const maxCacheFiles = 5000;
+const staleCacheAgeMs = 7 * 24 * 60 * 60 * 1000;
+const stableStringify = (value) => {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+};
+const hashValue = (value) => {
+    return crypto
+        .createHash('sha256')
+        .update(stableStringify(value))
+        .digest('hex');
+};
+const hashFile = (file) => {
+    return crypto.createHash('md5').update(fs.readFileSync(file)).digest('hex');
+};
+const normalizeCachePath = (file) => {
+    return toPosixPath(path.resolve(file));
+};
+const normalizeRealpath = (file) => {
+    return toPosixPath(fs.realpathSync.native(file));
+};
+const statCachedFile = (file) => {
+    const resolved = path.resolve(file);
+    if (!fs.existsSync(resolved)) {
+        return {
+            file: normalizeCachePath(file),
+            exists: false,
+        };
+    }
+    const stat = fs.statSync(resolved);
+    if (stat.isDirectory()) {
+        return {
+            file: normalizeCachePath(file),
+            exists: true,
+            realpath: normalizeRealpath(resolved),
+            type: 'directory',
+            mtimeMs: stat.mtimeMs,
+            size: stat.size,
+        };
+    }
+    if (!stat.isFile()) {
+        return {
+            file: normalizeCachePath(file),
+            exists: false,
+        };
+    }
+    return {
+        hash: hashFile(resolved),
+        file: normalizeCachePath(file),
+        exists: true,
+        realpath: normalizeRealpath(resolved),
+        type: 'file',
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+    };
+};
+export class PersistentStyleGraphCache {
+    static cleanedRoots = new Set();
+    cacheRoot;
+    constructor(options) {
+        this.cacheRoot = path.join(options.root, 'node_modules', '.auklet', 'cache', 'vite-style', cacheVersion);
+    }
+    createKey(value) {
+        return hashValue({
+            cacheVersion,
+            value,
+        });
+    }
+    read(key) {
+        const cacheFile = this.getCacheFile(key);
+        if (!fs.existsSync(cacheFile))
+            return null;
+        try {
+            const cached = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+            if (cached.key !== key)
+                return null;
+            if (!this.isFresh(cached.files))
+                return null;
+            return cached.result;
+        }
+        catch {
+            return null;
+        }
+    }
+    write(key, result, inputFiles) {
+        const files = Array.from(new Map(inputFiles
+            .map((file) => statCachedFile(file))
+            .map((file) => [file.file, file])).values());
+        try {
+            fs.mkdirSync(this.cacheRoot, { recursive: true });
+            fs.writeFileSync(this.getCacheFile(key), `${JSON.stringify({
+                files,
+                key,
+                result,
+            }, null, 2)}\n`);
+        }
+        catch {
+            // Cache writes are an optimization; dev CSS generation must keep working.
+            return;
+        }
+        this.cleanupStaleEntries();
+    }
+    cleanupStaleEntries() {
+        if (PersistentStyleGraphCache.cleanedRoots.has(this.cacheRoot))
+            return;
+        PersistentStyleGraphCache.cleanedRoots.add(this.cacheRoot);
+        try {
+            const now = Date.now();
+            const entries = fs
+                .readdirSync(this.cacheRoot, { withFileTypes: true })
+                .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+                .map((entry) => {
+                const file = path.join(this.cacheRoot, entry.name);
+                return {
+                    file,
+                    mtimeMs: fs.statSync(file).mtimeMs,
+                };
+            });
+            const freshEntries = [];
+            for (const entry of entries) {
+                if (now - entry.mtimeMs > staleCacheAgeMs) {
+                    fs.unlinkSync(entry.file);
+                    continue;
+                }
+                freshEntries.push(entry);
+            }
+            const overflowCount = freshEntries.length - maxCacheFiles;
+            if (overflowCount <= 0)
+                return;
+            for (const entry of freshEntries
+                .sort((left, right) => left.mtimeMs - right.mtimeMs)
+                .slice(0, overflowCount)) {
+                fs.unlinkSync(entry.file);
+            }
+        }
+        catch {
+            // Cache cleanup is best-effort and must not affect dev CSS generation.
+        }
+    }
+    getCacheFile(key) {
+        return path.join(this.cacheRoot, `${key}.json`);
+    }
+    isFresh(files) {
+        for (const file of files) {
+            const current = statCachedFile(file.file);
+            if (current.exists !== file.exists)
+                return false;
+            if (!current.exists || !file.exists)
+                continue;
+            if (current.type !== file.type)
+                return false;
+            if (current.realpath !== file.realpath ||
+                current.size !== file.size ||
+                current.mtimeMs !== file.mtimeMs ||
+                toPosixPath(current.file) !== toPosixPath(file.file)) {
+                return false;
+            }
+            if (current.type === 'file' &&
+                file.type === 'file' &&
+                current.hash !== file.hash) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

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

@@ -3,7 +3,7 @@ import type { ModuleStyleBuildConfig, NormalizedAukletConfig, ResolvedModuleStyl
 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 } from '#auklet/css/vite/moduleGraph/types';
+import type { LoadAukletConfig, PackageStyleId, PackageStyleLoadResult } from '#auklet/css/vite/moduleGraph/types';
 export type PackageStyleContext = {
     normalizedConfig: NormalizedAukletConfig;
     context: ResolvedModuleStyleBuildContext;
@@ -15,6 +15,8 @@ export type PackageStyleContext = {
     styleProcessor: StyleProcessor;
 };
 export type ModuleStyleGraphRequestCacheOptions = {
+    root: string;
+    mode: 'monorepo' | 'package';
     packageSource: StylePackageSource;
     config: ModuleStyleBuildConfig;
     loadAukletConfig?: LoadAukletConfig;
@@ -22,7 +24,10 @@ export type ModuleStyleGraphRequestCacheOptions = {
 export declare class ModuleStyleGraphRequestCache {
     private readonly options;
     private readonly contexts;
+    private readonly loadResults;
+    private readonly loadResultDependencies;
     private readonly loadAukletConfig;
+    private readonly persistentCache;
     constructor(options: ModuleStyleGraphRequestCacheOptions);
     getPackageNames(): string[];
     isKnownPackageName(packageName: string): boolean;
@@ -62,6 +67,23 @@ export declare class ModuleStyleGraphRequestCache {
         sourceRoot: string;
         styleProcessor: StyleProcessor;
     } | null>;
+    getLoadResult(parsed: PackageStyleId, create: () => Promise<PackageStyleLoadResult>): Promise<PackageStyleLoadResult>;
     invalidatePackage(packageName: string): void;
+    readPersistentLoadResult(parsed: PackageStyleId, context: PackageStyleContext): PackageStyleLoadResult | null;
+    writePersistentLoadResult(parsed: PackageStyleId, context: PackageStyleContext, result: PackageStyleLoadResult): {
+        cacheInputFiles: string[];
+        code: string;
+        watchFiles: Array<string>;
+        dependencyPackages?: Array<string>;
+    };
     private createContext;
+    private createPersistentKey;
+    private getPersistentInputFiles;
+    private getPackageKeyEntries;
+    private getWorkspaceInputFiles;
+    private getSourceInputFiles;
+    private getResolutionInputFiles;
+    private getLoadResultKey;
+    private getLoadResultPackageName;
+    private invalidateLoadResults;
 }

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

@@ -2,13 +2,21 @@ import path from 'node:path';
 import { loadAukletConfig, resolveAukletConfigPath, } from '#auklet/configLoader';
 import { aukletConfigFiles, normalizeAukletConfig } from '#auklet/config';
 import { StylePackageContext } from '#auklet/css/core/stylePackageContext';
+import { PersistentStyleGraphCache } from '#auklet/css/vite/moduleGraph/persistentCache';
+import { normalizeFileKey, toPosixPath } from '#auklet/utils';
 export class ModuleStyleGraphRequestCache {
     options;
     contexts = new Map();
+    loadResults = new Map();
+    loadResultDependencies = new Map();
     loadAukletConfig;
+    persistentCache;
     constructor(options) {
         this.options = options;
         this.loadAukletConfig = options.loadAukletConfig ?? loadAukletConfig;
+        this.persistentCache = new PersistentStyleGraphCache({
+            root: options.root,
+        });
     }
     getPackageNames() {
         return this.options.packageSource.getPackageNames();
@@ -24,8 +32,33 @@ export class ModuleStyleGraphRequestCache {
         this.contexts.set(parsed.packageName, context);
         return context;
     }
+    getLoadResult(parsed, create) {
+        const key = this.getLoadResultKey(parsed);
+        const cachedResult = this.loadResults.get(key);
+        if (cachedResult)
+            return cachedResult;
+        const result = create().then((value) => {
+            this.loadResultDependencies.set(key, new Set(value.dependencyPackages ?? []));
+            return value;
+        });
+        this.loadResults.set(key, result);
+        return result;
+    }
     invalidatePackage(packageName) {
         this.contexts.delete(packageName);
+        this.invalidateLoadResults(packageName);
+    }
+    readPersistentLoadResult(parsed, context) {
+        return this.persistentCache.read(this.createPersistentKey(parsed, context));
+    }
+    writePersistentLoadResult(parsed, context, result) {
+        const cacheInputFiles = this.getPersistentInputFiles(context, result);
+        const cacheResult = {
+            ...result,
+            cacheInputFiles,
+        };
+        this.persistentCache.write(this.createPersistentKey(parsed, context), cacheResult, cacheInputFiles);
+        return cacheResult;
     }
     async createContext(parsed) {
         const stylePackage = this.options.packageSource
@@ -63,4 +96,118 @@ export class ModuleStyleGraphRequestCache {
             styleProcessor: packageContext.styleProcessor,
         };
     }
+    createPersistentKey(parsed, context) {
+        return this.persistentCache.createKey({
+            config: this.options.config,
+            mode: this.options.mode,
+            normalizedConfig: context.normalizedConfig,
+            packageName: context.packageName,
+            packageNames: this.getPackageNames(),
+            packages: this.getPackageKeyEntries(),
+            packageRoot: normalizeFileKey(context.context.packageRoot),
+            parsed,
+            root: normalizeFileKey(this.options.root),
+            sourceFiles: context.packageContext.sourceFiles.map((file) => toPosixPath(path.relative(context.sourceRoot, file))),
+            sourceRoot: normalizeFileKey(context.sourceRoot),
+        });
+    }
+    getPersistentInputFiles(context, result) {
+        return [
+            ...result.watchFiles,
+            ...(result.cacheInputFiles ?? []),
+            ...this.getSourceInputFiles(context.sourceRoot, context.packageContext.sourceFiles),
+            ...this.getResolutionInputFiles(context.context.packageRoot),
+            ...this.getWorkspaceInputFiles(),
+        ];
+    }
+    getPackageKeyEntries() {
+        return this.options.packageSource
+            .getPackages()
+            .map((item) => ({
+            packageName: item.packageName,
+            packageRoot: normalizeFileKey(item.packageRoot),
+        }))
+            .sort((left, right) => {
+            const nameOrder = left.packageName.localeCompare(right.packageName);
+            if (nameOrder !== 0)
+                return nameOrder;
+            return left.packageRoot.localeCompare(right.packageRoot);
+        });
+    }
+    getWorkspaceInputFiles() {
+        if (this.options.mode !== 'monorepo')
+            return [];
+        return [path.join(this.options.root, 'pnpm-workspace.yaml')];
+    }
+    getSourceInputFiles(sourceRoot, sourceFiles) {
+        const sourceInputFiles = new Set([sourceRoot, ...sourceFiles]);
+        const normalizedSourceRoot = normalizeFileKey(sourceRoot);
+        for (const file of sourceFiles) {
+            let current = path.dirname(file);
+            let currentKey = normalizeFileKey(current);
+            while (currentKey === normalizedSourceRoot ||
+                currentKey.startsWith(`${normalizedSourceRoot}/`)) {
+                sourceInputFiles.add(current);
+                if (currentKey === normalizedSourceRoot)
+                    break;
+                const parent = path.dirname(current);
+                current = parent;
+                currentKey = normalizeFileKey(current);
+            }
+        }
+        return Array.from(sourceInputFiles);
+    }
+    getResolutionInputFiles(packageRoot) {
+        const files = [path.join(packageRoot, 'package.json')];
+        let current = packageRoot;
+        const graphRoot = normalizeFileKey(this.options.root);
+        let reachedGraphRoot = false;
+        while (!reachedGraphRoot) {
+            const tsconfig = path.join(current, 'tsconfig.json');
+            files.push(tsconfig);
+            reachedGraphRoot = normalizeFileKey(current) === graphRoot;
+            if (reachedGraphRoot)
+                break;
+            const parent = path.dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+        }
+        return Array.from(new Set(files));
+    }
+    getLoadResultKey(parsed) {
+        return `${parsed.packageName}\0${parsed.stylePath}`;
+    }
+    getLoadResultPackageName(key) {
+        return key.split('\0')[0];
+    }
+    invalidateLoadResults(packageName) {
+        const invalidPackageNames = new Set([packageName]);
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const [key, dependencyPackages] of this.loadResultDependencies) {
+                const resultPackageName = this.getLoadResultPackageName(key);
+                const shouldInvalidate = invalidPackageNames.has(resultPackageName) ||
+                    Array.from(dependencyPackages).some((dependencyPackage) => invalidPackageNames.has(dependencyPackage));
+                if (!shouldInvalidate)
+                    continue;
+                if (!invalidPackageNames.has(resultPackageName)) {
+                    invalidPackageNames.add(resultPackageName);
+                    changed = true;
+                }
+            }
+        }
+        for (const key of this.loadResults.keys()) {
+            if (!invalidPackageNames.has(this.getLoadResultPackageName(key))) {
+                const dependencyPackages = this.loadResultDependencies.get(key);
+                if (!dependencyPackages ||
+                    !Array.from(dependencyPackages).some((dependencyPackage) => invalidPackageNames.has(dependencyPackage))) {
+                    continue;
+                }
+            }
+            this.loadResults.delete(key);
+            this.loadResultDependencies.delete(key);
+        }
+    }
 }

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

@@ -1,13 +1,11 @@
 import type { ModuleStyleBuildConfig } from '#auklet/types';
 import type { ModuleStyleGraphRequestCache } from '#auklet/css/vite/moduleGraph/requestCache';
-import type { PackageStyleId } from '#auklet/css/vite/moduleGraph/types';
+import type { PackageStyleId, PackageStyleLoadResult } from '#auklet/css/vite/moduleGraph/types';
 export declare class StyleCodeFactory {
     private readonly config;
     constructor(config: ModuleStyleBuildConfig);
-    createPackageStyleCode(parsed: PackageStyleId, cache: ModuleStyleGraphRequestCache): Promise<{
-        code: string;
-        watchFiles: string[];
-    }>;
+    createPackageStyleCode(parsed: PackageStyleId, cache: ModuleStyleGraphRequestCache): Promise<PackageStyleLoadResult>;
+    private createUncachedPackageStyleCode;
     private createStyleCode;
     private createDependencyStyleCode;
     private createExternalStyleCode;
@@ -17,4 +15,5 @@ export declare class StyleCodeFactory {
     private toDevModuleImportSpecifier;
     private toDevExternalStyleSpecifier;
     private parsePackageStyleIdInRequest;
+    private withDependencyPackage;
 }

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

@@ -12,6 +12,9 @@ export class StyleCodeFactory {
         this.config = config;
     }
     async createPackageStyleCode(parsed, cache) {
+        return cache.getLoadResult(parsed, () => this.createUncachedPackageStyleCode(parsed, cache));
+    }
+    async createUncachedPackageStyleCode(parsed, cache) {
         const context = await cache.getContext(parsed);
         if (!context) {
             return {
@@ -19,21 +22,28 @@ export class StyleCodeFactory {
                 watchFiles: [],
             };
         }
+        const cachedResult = cache.readPersistentLoadResult(parsed, context);
+        if (cachedResult)
+            return cachedResult;
+        let result;
         if (parsed.stylePath === STYLE_ENTRY) {
-            return this.createStyleCode(context, cache);
+            result = await this.createStyleCode(context, cache);
         }
-        if (parsed.stylePath === EXTERNAL_ENTRY) {
-            return this.createExternalStyleCode(context, cache);
+        else if (parsed.stylePath === EXTERNAL_ENTRY) {
+            result = await this.createExternalStyleCode(context, cache);
         }
-        if (parsed.stylePath === MODULE_ENTRY) {
-            return this.createModuleStyleCode(context);
+        else if (parsed.stylePath === MODULE_ENTRY) {
+            result = this.createModuleStyleCode(context);
         }
-        if (parsed.stylePath.startsWith(THEMES_ENTRY_PREFIX)) {
-            return this.createThemeStyleCode(context, cache, [
+        else if (parsed.stylePath.startsWith(THEMES_ENTRY_PREFIX)) {
+            result = await this.createThemeStyleCode(context, cache, [
                 removeStyleExtension(parsed.stylePath.slice(THEMES_ENTRY_PREFIX.length)),
             ]);
         }
-        return this.createSourceModuleStyleCode(context, cache, parsed.stylePath);
+        else {
+            result = await this.createSourceModuleStyleCode(context, cache, parsed.stylePath);
+        }
+        return cache.writePersistentLoadResult(parsed, context, result);
     }
     async createStyleCode(context, cache) {
         const results = [];
@@ -52,23 +62,27 @@ export class StyleCodeFactory {
     }
     async createDependencyStyleCode(context, cache, specifiers, mapSpecifier = (specifier) => specifier) {
         const results = [];
+        const cacheInputFiles = [];
         const imports = [];
         const watchFiles = [...context.configPaths];
         for (const specifier of specifiers) {
             const outputSpecifier = mapSpecifier(specifier);
             const parsed = this.parsePackageStyleIdInRequest(outputSpecifier, cache);
             if (parsed) {
-                results.push(await this.createPackageStyleCode(parsed, cache));
+                const result = await this.createPackageStyleCode(parsed, cache);
+                results.push(this.withDependencyPackage(result, parsed.packageName));
                 continue;
             }
             const resolvedSpecifier = toDevDependencyImportSpecifier(context, outputSpecifier);
             imports.push(resolvedSpecifier.specifier);
+            cacheInputFiles.push(...(resolvedSpecifier.cacheInputFiles ?? []));
             if (resolvedSpecifier.watchFile) {
                 watchFiles.push(resolvedSpecifier.watchFile);
             }
         }
         return mergeLoadResults({
             code: createImportCode(imports),
+            cacheInputFiles,
             watchFiles,
         }, ...results);
     }
@@ -133,15 +147,18 @@ export class StyleCodeFactory {
         const moduleStyleResults = [];
         const moduleStyleSpecifiers = [];
         const moduleStyleWatchFiles = [];
+        const moduleStyleCacheInputFiles = [];
         for (const specifier of entry.moduleStyleImports) {
             const result = this.toDevModuleImportSpecifier(specifier, context, cache, sourceStyleDir);
             const parsed = this.parsePackageStyleIdInRequest(result, cache);
             if (parsed) {
-                moduleStyleResults.push(await this.createPackageStyleCode(parsed, cache));
+                const loadResult = await this.createPackageStyleCode(parsed, cache);
+                moduleStyleResults.push(this.withDependencyPackage(loadResult, parsed.packageName));
                 continue;
             }
             const resolvedSpecifier = toDevDependencyImportSpecifier(context, result);
             moduleStyleSpecifiers.push(resolvedSpecifier.specifier);
+            moduleStyleCacheInputFiles.push(...(resolvedSpecifier.cacheInputFiles ?? []));
             if (resolvedSpecifier.watchFile) {
                 moduleStyleWatchFiles.push(resolvedSpecifier.watchFile);
             }
@@ -167,6 +184,7 @@ export class StyleCodeFactory {
                 ...moduleStyleWatchFiles,
                 ...sourceFiles.filter((file) => /\.(ts|tsx)$/.test(file)),
             ],
+            cacheInputFiles: moduleStyleCacheInputFiles,
         });
     }
     toDevModuleImportSpecifier(specifier, context, cache, sourceStyleDir) {
@@ -190,4 +208,10 @@ export class StyleCodeFactory {
     parsePackageStyleIdInRequest(id, cache) {
         return parsePackageStyleId(id, cache.getPackageNames());
     }
+    withDependencyPackage(result, packageName) {
+        return {
+            ...result,
+            dependencyPackages: Array.from(new Set([packageName, ...(result.dependencyPackages ?? [])])),
+        };
+    }
 }

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

@@ -11,7 +11,9 @@ export type PackageStyleId = {
 };
 export type PackageStyleLoadResult = {
     code: string;
+    cacheInputFiles?: Array<string>;
     watchFiles: Array<string>;
+    dependencyPackages?: Array<string>;
 };
 export type LoadAukletConfig = (packageRoot: string, options?: {
     cacheBust?: boolean;

package/dist/css/vite/vitePlugin.js

@@ -130,7 +130,7 @@ export function aukletStylePlugin(options = {}) {
                     return;
                 }
                 if (graph.isSourceModuleFile(file)) {
-                    reloadStyleGraph(file);
+                    hmr.handleSourceModuleChange(server, file);
                 }
             });
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",