auklet 0.3.0 → 0.3.2

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

@@ -23,6 +23,7 @@ export declare class StyleProcessor {
     private throwMissingLocalStyleImport;
     collectImportedStyleFiles(styleFiles: Array<string>): Set<string>;
     collectImportedStyleFileReferences(styleFiles: Array<string>): StyleFileImportReference[];
+    collectStyleImportReferences(styleFiles: Array<string>): StyleFileImportReference[];
     collectStyleImportSpecifiers(styleFiles: Array<string>): Set<string>;
     assertNoLocalStyleImportCycles(styleFiles: Array<string>): void;
     assertNoSourceRootEscapingLocalStyleImports(styleFiles: Array<string>): void;

package/dist/css/core/styleProcessor.js

@@ -98,6 +98,21 @@ export class StyleProcessor {
         }
         return imports;
     }
+    collectStyleImportReferences(styleFiles) {
+        const imports = [];
+        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)
+                    return;
+                const { reference } = this.resolveStyleImportReference(specifier, styleFile);
+                imports.push(reference);
+            });
+        }
+        return imports;
+    }
     collectStyleImportSpecifiers(styleFiles) {
         const specifiers = new Set();
         for (const styleFile of styleFiles) {

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

@@ -1,5 +1,6 @@
 import type { HotUpdateOptions, ViteDevServer } from 'vite';
 import type { ModuleStyleGraph } from '#auklet/css/vite/moduleGraph/graph';
+type TrackedVirtualStyleFileKind = 'entry' | 'dependency';
 export type AukletStyleHmrOptions = {
     pruneDelayMs?: number;
 };
@@ -12,8 +13,11 @@ export declare class AukletStyleHmr {
     private readonly schedulePruneStaleVirtualDependencies;
     private readonly pruneDelayMs;
     constructor(graph: () => ModuleStyleGraph, options?: AukletStyleHmrOptions);
-    trackVirtualStyleDependency(file: string, virtualId: string): void;
-    replaceVirtualStyleDependency(virtualId: string, files: Array<string>): void;
+    trackVirtualStyleDependency(file: string, virtualId: string, kind?: TrackedVirtualStyleFileKind): void;
+    replaceVirtualStyleDependency(virtualId: string, files: Array<string>, fileKinds?: Array<{
+        file: string;
+        kind: TrackedVirtualStyleFileKind;
+    }>): void;
     hasTrackedStyleDependency(file: string, moduleGraph?: Pick<ViteDevServer['moduleGraph'], 'getModuleById'>): boolean;
     pruneStaleVirtualDependencies(moduleGraph: Pick<ViteDevServer['moduleGraph'], 'getModuleById'>): void;
     scheduleStaleVirtualDependencyPrune(moduleGraph: Pick<ViteDevServer['moduleGraph'], 'getModuleById'>): void;
@@ -21,13 +25,18 @@ export declare class AukletStyleHmr {
     installFullReloadGuard(server: Pick<ViteDevServer, 'ws'>): void;
     handleStyleHotUpdate(context: HotUpdateOptions): Promise<never[] | undefined>;
     handleSourceModuleChange(server: Pick<ViteDevServer, 'moduleGraph' | 'ws'>, file: string): Promise<boolean>;
-    private sendVirtualStyleUpdates;
     private parseTrackedVirtualIds;
+    private createTrackedVirtualStyleUpdates;
+    private invalidateTrackedVirtualPackages;
     private getDependencyVirtualIds;
-    private parseTrackedVirtualId;
+    private getTrackedStyleFileEntries;
     private createTrackedVirtualStyleResults;
-    private refreshSourceModuleUpdates;
+    private parseTrackedVirtualId;
+    private parseTrackedVirtualIdWithKind;
+    private refreshTrackedVirtualStyleUpdates;
+    private sameStyleLoadResult;
     private suppressFullReload;
     private shouldSuppressFullReload;
     private isDuplicateUpdate;
 }
+export {};

package/dist/css/vite/hmr.js

@@ -12,13 +12,15 @@ const toBrowserVirtualPath = (id) => {
 const getRelativeFile = (file) => {
     return path.relative(process.cwd(), file);
 };
-const addVirtualStyleDependency = (virtualIdsByDependency, filesByVirtualId, file, virtualId) => {
+const addVirtualStyleDependency = (virtualIdsByDependency, filesByVirtualId, file, virtualId, kind) => {
     const normalizedFile = normalizeFileKey(file);
     const values = virtualIdsByDependency.get(normalizedFile) ?? new Set();
     values.add(virtualId);
     virtualIdsByDependency.set(normalizedFile, values);
-    const files = filesByVirtualId.get(virtualId) ?? new Set();
-    files.add(normalizedFile);
+    const files = filesByVirtualId.get(virtualId) ??
+        new Map();
+    const previousKind = files.get(normalizedFile);
+    files.set(normalizedFile, previousKind === 'entry' || kind === 'entry' ? 'entry' : kind);
     filesByVirtualId.set(virtualId, files);
 };
 const removeVirtualStyleDependency = (virtualIdsByDependency, filesByVirtualId, file, virtualId) => {
@@ -72,19 +74,20 @@ export class AukletStyleHmr {
         this.pruneDelayMs = options.pruneDelayMs ?? 2 * 60 * 1000;
         this.schedulePruneStaleVirtualDependencies = throttle(this.pruneDelayMs, (moduleGraph) => this.pruneStaleVirtualDependencies(moduleGraph));
     }
-    trackVirtualStyleDependency(file, virtualId) {
-        addVirtualStyleDependency(this.virtualIdsByDependency, this.filesByVirtualId, file, virtualId);
+    trackVirtualStyleDependency(file, virtualId, kind = 'dependency') {
+        addVirtualStyleDependency(this.virtualIdsByDependency, this.filesByVirtualId, file, virtualId, kind);
     }
-    replaceVirtualStyleDependency(virtualId, files) {
+    replaceVirtualStyleDependency(virtualId, files, fileKinds = []) {
         const normalizedFiles = new Set(files.map((file) => normalizeFileKey(file)));
-        const previousFiles = this.filesByVirtualId.get(virtualId) ?? new Set();
-        for (const file of previousFiles) {
+        const previousFiles = this.filesByVirtualId.get(virtualId) ?? new Map();
+        const nextKinds = new Map(fileKinds.map((item) => [normalizeFileKey(item.file), item.kind]));
+        for (const file of previousFiles.keys()) {
             if (normalizedFiles.has(file))
                 continue;
             removeVirtualStyleDependency(this.virtualIdsByDependency, this.filesByVirtualId, file, virtualId);
         }
         for (const file of normalizedFiles) {
-            addVirtualStyleDependency(this.virtualIdsByDependency, this.filesByVirtualId, file, virtualId);
+            addVirtualStyleDependency(this.virtualIdsByDependency, this.filesByVirtualId, file, virtualId, nextKinds.get(file) ?? 'dependency');
         }
     }
     hasTrackedStyleDependency(file, moduleGraph) {
@@ -123,20 +126,52 @@ export class AukletStyleHmr {
     }
     async handleStyleHotUpdate(context) {
         const graph = this.graph();
-        if (!graph.isSourceGraphFile(context.file) ||
-            !graph.isStyleFile(context.file)) {
-            return;
+        if (!graph.isStyleFile(context.file)) {
+            return undefined;
+        }
+        const isSourceGraphFile = graph.isSourceGraphFile(context.file);
+        const trackedEntries = this.getTrackedStyleFileEntries(context.file, context.server.moduleGraph);
+        if (!trackedEntries.length) {
+            if (isSourceGraphFile) {
+                graph.invalidateFile(context.file);
+            }
+            return undefined;
+        }
+        const entryEntries = isSourceGraphFile
+            ? trackedEntries.filter((item) => item.kind === 'entry')
+            : [];
+        const dependencyEntries = isSourceGraphFile
+            ? trackedEntries.filter((item) => item.kind === 'dependency')
+            : trackedEntries;
+        const previousResults = entryEntries.length
+            ? this.createTrackedVirtualStyleResults(graph, entryEntries)
+            : null;
+        if (isSourceGraphFile) {
+            graph.invalidateFile(context.file);
+        }
+        else {
+            this.invalidateTrackedVirtualPackages(graph, dependencyEntries);
         }
-        this.suppressFullReload();
-        graph.invalidateFile(context.file);
         if (this.isDuplicateUpdate(context.file)) {
             return [];
         }
-        const updates = this.sendVirtualStyleUpdates(context.file, context.server, context.timestamp);
-        if (!updates.sent) {
-            return [];
+        const updates = [
+            ...(dependencyEntries.length
+                ? this.createTrackedVirtualStyleUpdates(context.server, dependencyEntries, context.timestamp)
+                : []),
+            ...(entryEntries.length
+                ? await this.refreshTrackedVirtualStyleUpdates(context.server, entryEntries, previousResults, context.timestamp)
+                : []),
+        ];
+        if (!updates.length) {
+            return undefined;
         }
-        logger.info(`package css hmr ${getRelativeFile(context.file)} tracked=${updates.tracked} updates=${updates.sent}`);
+        this.suppressFullReload();
+        context.server.ws.send({
+            type: 'update',
+            updates,
+        });
+        logger.info(`package css hmr ${getRelativeFile(context.file)} tracked=${trackedEntries.length} updates=${updates.length}`);
         return [];
     }
     async handleSourceModuleChange(server, file) {
@@ -156,37 +191,39 @@ export class AukletStyleHmr {
         }
         const previousResults = this.createTrackedVirtualStyleResults(graph, parsedVirtualIds);
         graph.invalidateFile(file);
-        const updates = await this.refreshSourceModuleUpdates(server, parsedVirtualIds, previousResults);
-        if (!updates.sent) {
+        const updates = await this.refreshTrackedVirtualStyleUpdates(server, parsedVirtualIds, previousResults, Date.now());
+        if (!updates.length) {
             return false;
         }
-        logger.info(`package css source hmr ${getRelativeFile(file)} tracked=${updates.tracked} updates=${updates.sent}`);
-        return updates.sent > 0;
+        this.suppressFullReload();
+        server.ws.send({
+            type: 'update',
+            updates,
+        });
+        logger.info(`package css source hmr ${getRelativeFile(file)} tracked=${parsedVirtualIds.length} updates=${updates.length}`);
+        return true;
     }
-    sendVirtualStyleUpdates(file, server, timestamp) {
-        const virtualIds = this.getDependencyVirtualIds(file, server.moduleGraph);
-        for (const id of virtualIds) {
-            const module = server.moduleGraph.getModuleById(id);
+    parseTrackedVirtualIds(graph, virtualIds) {
+        return virtualIds
+            .map((id) => this.parseTrackedVirtualId(graph, id))
+            .filter((item) => item !== null);
+    }
+    createTrackedVirtualStyleUpdates(server, parsedVirtualIds, timestamp) {
+        const changedVirtualIds = [];
+        for (const item of parsedVirtualIds) {
+            changedVirtualIds.push(item.id);
+            const module = server.moduleGraph.getModuleById(item.id);
             if (module) {
                 server.moduleGraph.invalidateModule(module);
             }
         }
-        const updates = createJsUpdates(virtualIds, timestamp);
-        if (updates.length) {
-            server.ws.send({
-                type: 'update',
-                updates,
-            });
-        }
-        return {
-            sent: updates.length,
-            tracked: virtualIds.length,
-        };
+        return createJsUpdates(changedVirtualIds, timestamp);
     }
-    parseTrackedVirtualIds(graph, virtualIds) {
-        return virtualIds
-            .map((id) => this.parseTrackedVirtualId(graph, id))
-            .filter((item) => Boolean(item));
+    invalidateTrackedVirtualPackages(graph, parsedVirtualIds) {
+        const packageNames = new Set(parsedVirtualIds.map((item) => item.parsed.packageName));
+        for (const packageName of packageNames) {
+            graph.invalidatePackage(packageName);
+        }
     }
     getDependencyVirtualIds(file, moduleGraph) {
         const normalizedFile = normalizeFileKey(file);
@@ -205,6 +242,32 @@ export class AukletStyleHmr {
         }
         return liveVirtualIds;
     }
+    getTrackedStyleFileEntries(file, moduleGraph) {
+        const normalizedFile = normalizeFileKey(file);
+        const virtualIds = Array.from(this.virtualIdsByDependency.get(normalizedFile) ?? []);
+        const entries = virtualIds
+            .map((id) => this.parseTrackedVirtualIdWithKind(id, normalizedFile, moduleGraph))
+            .filter((item) => Boolean(item));
+        if (!moduleGraph) {
+            return entries;
+        }
+        if (entries.length !== virtualIds.length) {
+            const liveSet = new Set(entries.map((item) => item.id));
+            for (const virtualId of virtualIds) {
+                if (liveSet.has(virtualId))
+                    continue;
+                removeVirtualStyleDependency(this.virtualIdsByDependency, this.filesByVirtualId, normalizedFile, virtualId);
+            }
+        }
+        return entries;
+    }
+    createTrackedVirtualStyleResults(graph, parsedVirtualIds) {
+        const previousResults = new Map();
+        for (const item of parsedVirtualIds) {
+            previousResults.set(item.id, graph.peekPackageStyleCode(item.parsed));
+        }
+        return previousResults;
+    }
     parseTrackedVirtualId(graph, id) {
         const parsedId = id.startsWith(RESOLVED_VIRTUAL_ID_PREFIX)
             ? id.slice(RESOLVED_VIRTUAL_ID_PREFIX.length)
@@ -216,24 +279,30 @@ export class AukletStyleHmr {
         return {
             id,
             parsed,
+            kind: 'dependency',
         };
     }
-    createTrackedVirtualStyleResults(graph, parsedVirtualIds) {
-        const previousResults = new Map();
-        for (const item of parsedVirtualIds) {
-            previousResults.set(item.id, graph.peekPackageStyleCode(item.parsed));
+    parseTrackedVirtualIdWithKind(id, normalizedFile, moduleGraph) {
+        if (moduleGraph && !moduleGraph.getModuleById(id)) {
+            return null;
         }
-        return previousResults;
+        const parsed = this.parseTrackedVirtualId(this.graph(), id);
+        if (!parsed)
+            return null;
+        const kind = this.filesByVirtualId.get(id)?.get(normalizedFile) ?? 'dependency';
+        return {
+            ...parsed,
+            kind,
+        };
     }
-    async refreshSourceModuleUpdates(server, parsedVirtualIds, previousResults) {
+    async refreshTrackedVirtualStyleUpdates(server, parsedVirtualIds, previousResults, timestamp) {
         const graph = this.graph();
         const changedVirtualIds = [];
         for (const item of parsedVirtualIds) {
             const nextResult = await graph.createPackageStyleCode(item.parsed);
             const previousResult = previousResults.get(item.id);
             if (!previousResult ||
-                previousResult.code !== nextResult.code ||
-                !sameStringSets(previousResult.watchFiles, nextResult.watchFiles)) {
+                !this.sameStyleLoadResult(previousResult, nextResult)) {
                 changedVirtualIds.push(item.id);
                 const module = server.moduleGraph.getModuleById(item.id);
                 if (module) {
@@ -241,17 +310,12 @@ export class AukletStyleHmr {
                 }
             }
         }
-        const updates = createJsUpdates(changedVirtualIds, Date.now());
-        if (updates.length) {
-            server.ws.send({
-                type: 'update',
-                updates,
-            });
-        }
-        return {
-            sent: updates.length,
-            tracked: parsedVirtualIds.length,
-        };
+        return createJsUpdates(changedVirtualIds, timestamp);
+    }
+    sameStyleLoadResult(left, right) {
+        return (left.code === right.code &&
+            sameStringSets(left.watchFiles, right.watchFiles) &&
+            sameStringSets(left.dependencyPackages ?? [], right.dependencyPackages ?? []));
     }
     suppressFullReload() {
         this.suppressFullReloadUntil = Date.now() + FULL_RELOAD_SUPPRESS_MS;

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

@@ -4,4 +4,8 @@ export declare function mergeLoadResults(...results: Array<PackageStyleLoadResul
     watchFiles: string[];
     cacheInputFiles: string[];
     dependencyPackages: string[];
+    watchFileKinds: {
+        file: string;
+        kind: "dependency" | "entry";
+    }[];
 };

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

@@ -1,5 +1,15 @@
 // 合并递归 style graph 加载结果，同时保留 CSS 顺序并去重 watch files。
 export function mergeLoadResults(...results) {
+    const watchFileKinds = new Map();
+    for (const result of results) {
+        for (const item of result.watchFileKinds ?? []) {
+            const currentKind = watchFileKinds.get(item.file);
+            if (currentKind === 'entry' || item.kind === currentKind) {
+                continue;
+            }
+            watchFileKinds.set(item.file, item.kind === 'entry' ? 'entry' : (currentKind ?? item.kind));
+        }
+    }
     return {
         code: results
             .map((result) => result.code)
@@ -8,5 +18,9 @@ export function mergeLoadResults(...results) {
         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 ?? []))),
+        watchFileKinds: Array.from(watchFileKinds, ([file, kind]) => ({
+            file,
+            kind,
+        })),
     };
 }

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

@@ -30,7 +30,9 @@ export declare class ModuleStyleGraphRequestCache {
     private readonly contexts;
     private readonly loadResults;
     private readonly settledLoadResults;
+    private readonly loadResultsByPackage;
     private readonly loadResultDependencies;
+    private readonly loadResultDependents;
     private readonly loadResultVersions;
     private readonly loadAukletConfig;
     private readonly persistentCache;
@@ -82,6 +84,7 @@ export declare class ModuleStyleGraphRequestCache {
         cacheInputFiles: string[];
         code: string;
         watchFiles: Array<string>;
+        watchFileKinds?: Array<import("#auklet/css/vite/moduleGraph/types").PackageStyleWatchFile>;
         dependencyPackages?: Array<string>;
     };
     private createContext;
@@ -99,5 +102,8 @@ export declare class ModuleStyleGraphRequestCache {
     private getGraphVersion;
     private bumpGraphVersion;
     private bumpLoadResultVersion;
+    private addLoadResultKey;
+    private deleteLoadResultKey;
+    private replaceLoadResultDependencies;
 }
 export {};

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

@@ -9,7 +9,9 @@ export class ModuleStyleGraphRequestCache {
     contexts = new Map();
     loadResults = new Map();
     settledLoadResults = new Map();
+    loadResultsByPackage = new Map();
     loadResultDependencies = new Map();
+    loadResultDependents = new Map();
     loadResultVersions = new Map();
     loadAukletConfig;
     persistentCache;
@@ -41,6 +43,7 @@ export class ModuleStyleGraphRequestCache {
         if (cachedResult)
             return cachedResult;
         const version = this.bumpLoadResultVersion(key);
+        this.addLoadResultKey(this.loadResultsByPackage, parsed.packageName, key);
         const graphVersion = this.getGraphVersion();
         let result;
         result = create()
@@ -54,7 +57,7 @@ export class ModuleStyleGraphRequestCache {
                 return this.getLoadResult(parsed, create);
             }
             if (this.loadResultVersions.get(key) === version) {
-                this.loadResultDependencies.set(key, new Set(entry.result.dependencyPackages ?? []));
+                this.replaceLoadResultDependencies(key, entry.result.dependencyPackages ?? []);
             }
             try {
                 const committedResult = entry.commit?.();
@@ -226,39 +229,46 @@ export class ModuleStyleGraphRequestCache {
         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))) {
+        const pendingKeys = [
+            ...(this.loadResultsByPackage.get(packageName) ?? []),
+            ...(this.loadResultDependents.get(packageName) ?? []),
+        ];
+        const processedKeys = new Set();
+        while (pendingKeys.length) {
+            const key = pendingKeys.pop();
+            if (!key || processedKeys.has(key))
+                continue;
+            processedKeys.add(key);
+            const dependentPackageName = this.discardLoadResult(key);
+            if (!dependentPackageName)
+                continue;
+            for (const dependentKey of Array.from(this.loadResultDependents.get(dependentPackageName) ?? [])) {
+                if (processedKeys.has(dependentKey))
                     continue;
-                }
+                pendingKeys.push(dependentKey);
             }
-            this.discardLoadResult(key);
         }
     }
     discardLoadResult(key) {
+        const packageName = this.getLoadResultPackageName(key);
+        const dependencyPackages = this.loadResultDependencies.get(key);
+        const settledResult = this.loadResults.get(key) ?? null;
+        if (!settledResult &&
+            !dependencyPackages &&
+            !this.settledLoadResults.has(key)) {
+            return null;
+        }
         this.bumpGraphVersion();
         this.bumpLoadResultVersion(key);
         this.loadResults.delete(key);
-        this.loadResultDependencies.delete(key);
         this.settledLoadResults.delete(key);
+        this.deleteLoadResultKey(this.loadResultsByPackage, packageName, key);
+        const previousDependencies = dependencyPackages ?? new Set();
+        for (const dependencyPackage of previousDependencies) {
+            this.deleteLoadResultKey(this.loadResultDependents, dependencyPackage, key);
+        }
+        this.loadResultDependencies.delete(key);
+        return packageName;
     }
     peekLoadResult(parsed) {
         return this.settledLoadResults.get(this.getLoadResultKey(parsed)) ?? null;
@@ -275,4 +285,33 @@ export class ModuleStyleGraphRequestCache {
         this.loadResultVersions.set(key, nextVersion);
         return nextVersion;
     }
+    addLoadResultKey(map, key, value) {
+        const values = map.get(key) ?? new Set();
+        values.add(value);
+        map.set(key, values);
+    }
+    deleteLoadResultKey(map, key, value) {
+        const values = map.get(key);
+        if (!values)
+            return;
+        values.delete(value);
+        if (!values.size) {
+            map.delete(key);
+        }
+    }
+    replaceLoadResultDependencies(key, dependencyPackages) {
+        const nextDependencies = new Set(dependencyPackages);
+        const previousDependencies = this.loadResultDependencies.get(key);
+        if (previousDependencies) {
+            for (const dependencyPackage of previousDependencies) {
+                if (nextDependencies.has(dependencyPackage))
+                    continue;
+                this.deleteLoadResultKey(this.loadResultDependents, dependencyPackage, key);
+            }
+        }
+        this.loadResultDependencies.set(key, nextDependencies);
+        for (const dependencyPackage of nextDependencies) {
+            this.addLoadResultKey(this.loadResultDependents, dependencyPackage, key);
+        }
+    }
 }

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

@@ -14,6 +14,7 @@ export declare class StyleCodeFactory {
     private createModuleStyleCode;
     private createSourceModuleStyleCode;
     private createOwnSourceStyleCode;
+    private collectSourceStyleWatchFiles;
     private toDevModuleImportSpecifier;
     private toDevExternalStyleSpecifier;
     private parsePackageStyleIdInRequest;

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

@@ -1,3 +1,4 @@
+import fs from 'node:fs';
 import path from 'node:path';
 import postcss from 'postcss';
 import { mergeLoadResults } from '#auklet/css/vite/moduleGraph/loadResult';
@@ -166,7 +167,7 @@ export class StyleCodeFactory {
     async createSourceModuleStyleCode(context, cache, stylePath) {
         context.packageContext.assertPreservedLocalStyleImports();
         const sourceModuleDir = removeStyleExtension(stylePath);
-        const { styleFiles, sourceFiles } = context.packageContext;
+        const { sourceFiles } = context.packageContext;
         const entry = createModuleStyleEntryPlan(context.packageContext, sourceModuleDir);
         const sourceStyleDir = path.join(context.sourceRoot, sourceModuleDir, this.config.output.styleDir);
         const moduleStyleResults = [];
@@ -189,16 +190,31 @@ export class StyleCodeFactory {
             }
         }
         const ownStyleCode = this.createOwnSourceStyleCode(context, entry.ownStyleFiles);
+        const sourceWatchFiles = this.collectSourceStyleWatchFiles(context, entry.ownStyleFiles);
         return mergeLoadResults(...moduleStyleResults, {
             code: [createImportCode(moduleStyleSpecifiers), ownStyleCode]
                 .filter((code) => code.trim())
                 .join('\n'),
             watchFiles: [
                 ...context.configPaths,
-                ...styleFiles,
+                ...sourceWatchFiles.map((item) => item.file),
                 ...moduleStyleWatchFiles,
                 ...sourceFiles.filter((file) => /\.(ts|tsx)$/.test(file)),
             ],
+            watchFileKinds: [
+                ...context.configPaths.map((file) => ({
+                    file,
+                    kind: 'dependency',
+                })),
+                ...sourceWatchFiles,
+                ...moduleStyleWatchFiles.map((file) => ({
+                    file,
+                    kind: 'dependency',
+                })),
+                ...sourceFiles
+                    .filter((file) => /\.(ts|tsx)$/.test(file))
+                    .map((file) => ({ file, kind: 'dependency' })),
+            ],
             cacheInputFiles: moduleStyleCacheInputFiles,
         });
     }
@@ -220,6 +236,42 @@ export class StyleCodeFactory {
         }
         return root.nodes?.length ? context.styleProcessor.stringify(root) : '';
     }
+    collectSourceStyleWatchFiles(context, styleFiles) {
+        const watchFiles = new Map();
+        const pending = styleFiles.map((file) => ({
+            file,
+            kind: 'entry',
+        }));
+        const visited = new Set();
+        while (pending.length) {
+            const current = pending.pop();
+            if (!current)
+                continue;
+            const styleFile = current.file;
+            const normalized = path.resolve(styleFile);
+            if (visited.has(normalized))
+                continue;
+            visited.add(normalized);
+            const previousKind = watchFiles.get(normalized);
+            watchFiles.set(normalized, previousKind === 'entry' || current.kind === 'entry'
+                ? 'entry'
+                : 'dependency');
+            for (const reference of context.styleProcessor.collectStyleImportReferences([normalized])) {
+                if (!context.resolver.isStyleFile(reference.imported) ||
+                    !fs.existsSync(reference.imported)) {
+                    continue;
+                }
+                pending.push({
+                    file: reference.imported,
+                    kind: 'dependency',
+                });
+            }
+        }
+        return Array.from(watchFiles, ([file, kind]) => ({
+            file,
+            kind,
+        }));
+    }
     toDevModuleImportSpecifier(specifier, context, cache, sourceStyleDir) {
         return createDevModuleStyleSpecifier(specifier, {
             sourceStyleDir,

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

@@ -9,10 +9,16 @@ export type PackageStyleId = {
     packageName: string;
     stylePath: string;
 };
+export type PackageStyleWatchFileKind = 'entry' | 'dependency';
+export type PackageStyleWatchFile = {
+    file: string;
+    kind: PackageStyleWatchFileKind;
+};
 export type PackageStyleLoadResult = {
     code: string;
     cacheInputFiles?: Array<string>;
     watchFiles: Array<string>;
+    watchFileKinds?: Array<PackageStyleWatchFile>;
     dependencyPackages?: Array<string>;
 };
 export type LoadAukletConfig = (packageRoot: string, options?: {

package/dist/css/vite/vitePlugin.js

@@ -113,7 +113,7 @@ export function aukletStylePlugin(options = {}) {
             if (moduleGraph) {
                 hmr.pruneStaleVirtualDependencies(moduleGraph);
             }
-            hmr.replaceVirtualStyleDependency(id, result.watchFiles);
+            hmr.replaceVirtualStyleDependency(id, result.watchFiles, result.watchFileKinds);
             for (const file of result.watchFiles) {
                 this.addWatchFile?.(file);
             }
@@ -150,8 +150,7 @@ export function aukletStylePlugin(options = {}) {
                         reloadStyleGraph(file);
                     }
                     else if (graph.isStyleFile(file)) {
-                        graph.invalidateFile(file);
-                        if (hmr.hasTrackedStyleDependency(file, server.moduleGraph)) {
+                        if (hmr.hasTrackedStyleDependency(file)) {
                             await hmr.handleStyleHotUpdate({
                                 file,
                                 modules: [],
@@ -161,6 +160,9 @@ export function aukletStylePlugin(options = {}) {
                                 read: async () => '',
                             });
                         }
+                        else {
+                            graph.invalidateFile(file);
+                        }
                     }
                     else if (graph.isSourceModuleFile(file)) {
                         await hmr.handleSourceModuleChange(server, file);

package/package.json

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