auklet 0.1.8 → 0.2.0

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

@@ -11,19 +11,6 @@ const toBrowserVirtualPath = (id) => {
 const getRelativeFile = (file) => {
     return path.relative(process.cwd(), file);
 };
-const invalidateVirtualModules = (server, graph) => {
-    const modules = [];
-    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}`);
-            if (!module)
-                continue;
-            server.moduleGraph.invalidateModule(module);
-            modules.push(module);
-        }
-    }
-    return modules;
-};
 const addVirtualStyleDependency = (virtualIdsByDependency, file, virtualId) => {
     const normalizedFile = normalizeFileKey(file);
     const values = virtualIdsByDependency.get(normalizedFile) ?? new Set();
@@ -39,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();
@@ -72,35 +72,42 @@ export class AukletStyleHmr {
             !graph.isStyleFile(context.file)) {
             return;
         }
+        this.suppressFullReload();
+        graph.invalidateFile(context.file);
         if (this.isDuplicateUpdate(context.file)) {
             return [];
         }
-        this.suppressFullReload();
-        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);
         }
-        invalidateVirtualModules(context.server, graph);
-        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/graph.d.ts

@@ -3,6 +3,7 @@ export declare class ModuleStyleGraph {
     private readonly config;
     private readonly packageSource;
     private readonly styleCodeFactory;
+    private readonly requestCache;
     private readonly loadAukletConfig;
     constructor(options: ModuleStyleGraphOptions);
     parsePackageStyleId(id: string): {
@@ -14,9 +15,9 @@ export declare class ModuleStyleGraph {
     isStyleFile(file: string): boolean;
     getPackageNames(): string[];
     getWatchRoots(): Promise<string[]>;
-    createPackageStyleCode(parsed: PackageStyleId): Promise<{
-        code: string;
-        watchFiles: string[];
-    }>;
-    private createRequestCache;
+    createPackageStyleCode(parsed: PackageStyleId): Promise<import("#auklet/css/vite/moduleGraph/types").PackageStyleLoadResult>;
+    invalidatePackage(packageName: string): void;
+    invalidateFile(file: string): string | null;
+    isSourceModuleFile(file: string): boolean;
+    private isPackageFile;
 }

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

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { isAukletConfigFile } from '#auklet/config';
 import { loadAukletConfig } from '#auklet/configLoader';
+import { SOURCE_MODULE_RE } from '#auklet/css/constants';
 import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { parsePackageStyleId } from '#auklet/css/vite/moduleGraph/styleId';
 import { StyleCodeFactory } from '#auklet/css/vite/moduleGraph/styleCodeFactory';
@@ -13,6 +14,7 @@ export class ModuleStyleGraph {
     config;
     packageSource;
     styleCodeFactory;
+    requestCache;
     loadAukletConfig;
     constructor(options) {
         this.config = options.config ?? moduleStyleBuildConfig;
@@ -29,6 +31,13 @@ export class ModuleStyleGraph {
                     styleExtensions: this.config.styleExtensions,
                     loadAukletConfig: this.loadAukletConfig,
                 });
+        this.requestCache = new ModuleStyleGraphRequestCache({
+            root: normalizeFileKey(options.root),
+            mode: options.mode ?? 'package',
+            packageSource: this.packageSource,
+            config: this.config,
+            loadAukletConfig: this.loadAukletConfig,
+        });
     }
     parsePackageStyleId(id) {
         return parsePackageStyleId(id, this.getPackageNames());
@@ -49,13 +58,29 @@ export class ModuleStyleGraph {
         return this.packageSource.getWatchRoots();
     }
     createPackageStyleCode(parsed) {
-        return this.styleCodeFactory.createPackageStyleCode(parsed, this.createRequestCache());
+        return this.styleCodeFactory.createPackageStyleCode(parsed, this.requestCache);
     }
-    createRequestCache() {
-        return new ModuleStyleGraphRequestCache({
-            packageSource: this.packageSource,
-            config: this.config,
-            loadAukletConfig: this.loadAukletConfig,
-        });
+    invalidatePackage(packageName) {
+        this.requestCache.invalidatePackage(packageName);
+    }
+    invalidateFile(file) {
+        if (!this.isSourceGraphFile(file))
+            return null;
+        const normalizedFile = normalizeFileKey(file);
+        const stylePackage = this.packageSource
+            .getPackages()
+            .find((item) => this.isPackageFile(item.packageRoot, normalizedFile));
+        if (!stylePackage)
+            return null;
+        this.invalidatePackage(stylePackage.packageName);
+        return stylePackage.packageName;
+    }
+    isSourceModuleFile(file) {
+        return SOURCE_MODULE_RE.test(normalizeFileKey(file));
+    }
+    isPackageFile(packageRoot, file) {
+        const normalizedPackageRoot = normalizeFileKey(packageRoot);
+        return (file === normalizedPackageRoot ||
+            file.startsWith(`${normalizedPackageRoot}/`));
     }
 }

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,13 @@
+import type { PackageStyleLoadResult } from '#auklet/css/vite/moduleGraph/types';
+export type PersistentStyleGraphCacheOptions = {
+    root: string;
+};
+export declare class PersistentStyleGraphCache {
+    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 getCacheFile;
+    private isFresh;
+}

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

@@ -0,0 +1,137 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { toPosixPath } from '#auklet/utils';
+const cacheVersion = 'v1';
+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 {
+    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.
+        }
+    }
+    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,5 +67,21 @@ 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 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,6 +32,34 @@ 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
             .getPackages()
@@ -60,4 +96,93 @@ 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(),
+            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),
+        ];
+    }
+    getSourceInputFiles(sourceRoot, sourceFiles) {
+        const sourceInputFiles = new Set([sourceRoot, ...sourceFiles]);
+        const normalizedSourceRoot = normalizeFileKey(sourceRoot);
+        for (const file of sourceFiles) {
+            let current = path.dirname(file);
+            while (true) {
+                sourceInputFiles.add(current);
+                if (normalizeFileKey(current) === normalizedSourceRoot)
+                    break;
+                const parent = path.dirname(current);
+                if (parent === current)
+                    break;
+                current = parent;
+            }
+        }
+        return Array.from(sourceInputFiles);
+    }
+    getResolutionInputFiles(packageRoot) {
+        const files = [path.join(packageRoot, 'package.json')];
+        let current = packageRoot;
+        const graphRoot = normalizeFileKey(this.options.root);
+        while (true) {
+            files.push(path.join(current, 'tsconfig.json'));
+            if (normalizeFileKey(current) === graphRoot)
+                break;
+            const parent = path.dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+        }
+        return 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 = [];
@@ -58,7 +68,8 @@ export class StyleCodeFactory {
             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);
@@ -137,7 +148,8 @@ export class StyleCodeFactory {
             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);
@@ -190,4 +202,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

@@ -106,6 +106,7 @@ export function aukletStylePlugin(options = {}) {
             const invalidateStyleGraph = (file) => {
                 if (!graph.isSourceGraphFile(file))
                     return false;
+                graph.invalidateFile(file);
                 invalidateVirtualModules(server, graph);
                 return true;
             };
@@ -116,7 +117,7 @@ export function aukletStylePlugin(options = {}) {
             };
             const handleSourceAddOrUnlink = (file) => {
                 if (graph.isStyleFile(file)) {
-                    invalidateStyleGraph(file);
+                    reloadStyleGraph(file);
                     return;
                 }
                 reloadStyleGraph(file);
@@ -126,6 +127,10 @@ export function aukletStylePlugin(options = {}) {
             server.watcher.on('change', (file) => {
                 if (graph.isStyleConfigFile(file)) {
                     reloadStyleGraph(file);
+                    return;
+                }
+                if (graph.isSourceModuleFile(file)) {
+                    hmr.handleSourceModuleChange(server, file);
                 }
             });
         },

package/package.json

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