auklet 0.2.2 → 0.2.4

package/dist/css/core/styleImports/collector.d.ts

@@ -9,6 +9,10 @@ export declare class ModuleStyleImportCollector {
     collect(files: Array<string>, config: NormalizedAukletConfig): Map<string, string[]>;
     private collectSourceImportStyle;
     private resolveSourceImportStyleEntry;
+    private appendResolvedSourceImportStyles;
+    private addAcceptedSourceImportEdge;
+    private hasSourceImportPath;
+    private hasSourceModule;
     private isInsideSourceRoot;
     private resolveSourceImportPaths;
     private toSourceBase;

package/dist/css/core/styleImports/collector.js

@@ -7,6 +7,7 @@ import { resolveRelativeSourceImport } from '#auklet/css/core/resolvers/relative
 import { resolvePackageImportsSourceImport } from '#auklet/css/core/resolvers/packageImports';
 import { resolveTsconfigPathsSourceImport } from '#auklet/css/core/resolvers/tsconfigPaths';
 import { matchStyleAutoImportRules, createStyleAutoImportRules, createStyleAutoImportSpecifier, createDirectStyleAutoImportSpecifier, } from '#auklet/css/core/styleImports/autoImportRules';
+const SOURCE_MODULE_EXTENSION = '.tsx';
 const SOURCE_EXTENSION_RE = /\.(?:[cm]?[jt]s|[jt]sx)$/;
 const SOURCE_INDEX_RE = new RegExp(`[/\\\\]index${SOURCE_EXTENSION_RE.source}`);
 export class ModuleStyleImportCollector {
@@ -22,6 +23,8 @@ export class ModuleStyleImportCollector {
     }
     collect(files, config) {
         const entries = new Map();
+        const sourceImportEdges = new Map();
+        const acceptedSourceImportEdges = new Map();
         const rules = createStyleAutoImportRules(config);
         for (const file of files) {
             if (!SOURCE_MODULE_RE.test(file)) {
@@ -33,7 +36,7 @@ export class ModuleStyleImportCollector {
             const code = fs.readFileSync(file, 'utf8');
             const imports = collectModuleImportReferences(file, code);
             for (const item of imports) {
-                this.collectSourceImportStyle(entries, sourceDir, sourceModuleDir, item);
+                this.collectSourceImportStyle(entries, sourceImportEdges, acceptedSourceImportEdges, sourceDir, sourceModuleDir, item);
                 if (isTypeOnlyModuleReference(item))
                     continue;
                 const importPath = item.importPath;
@@ -66,16 +69,28 @@ export class ModuleStyleImportCollector {
                 }
             }
         }
+        this.appendResolvedSourceImportStyles(entries, sourceImportEdges, acceptedSourceImportEdges);
         return entries;
     }
-    collectSourceImportStyle(entries, sourceDir, sourceModuleDir, item) {
+    collectSourceImportStyle(entries, sourceImportEdges, acceptedSourceImportEdges, sourceDir, sourceModuleDir, item) {
         if (isTypeOnlyModuleReference(item))
             return;
         const importedStyleEntry = this.resolveSourceImportStyleEntry(sourceDir, item.importPath);
         if (!importedStyleEntry)
             return;
         const sourceStyleDir = path.join(this.srcRoot, sourceModuleDir, 'style');
-        appendUniqueMapValue(entries, sourceModuleDir, this.toRelativeSpecifier(sourceStyleDir, importedStyleEntry));
+        const edge = {
+            ...importedStyleEntry,
+            specifier: this.toRelativeSpecifier(sourceStyleDir, importedStyleEntry.styleEntry),
+        };
+        if (importedStyleEntry.hasOwnStyle) {
+            if (!this.addAcceptedSourceImportEdge(acceptedSourceImportEdges, sourceModuleDir, edge.sourceDir)) {
+                return;
+            }
+            appendUniqueMapValue(entries, sourceModuleDir, edge.specifier);
+            return;
+        }
+        appendUniqueMapValue(sourceImportEdges, sourceModuleDir, edge);
     }
     resolveSourceImportStyleEntry(sourceDir, importPath) {
         const sourceRelativePaths = this.resolveSourceImportPaths(sourceDir, importPath);
@@ -84,17 +99,75 @@ export class ModuleStyleImportCollector {
             if (!this.isInsideSourceRoot(sourceBase))
                 continue;
             const directoryStyleEntry = path.join(sourceBase, 'style', 'index.css');
-            for (const extension of this.styleExtensions) {
-                const directorySourceStyle = path.join(sourceBase, `index${extension}`);
-                if (fs.existsSync(directorySourceStyle))
-                    return directoryStyleEntry;
+            const directorySourceStyle = this.styleExtensions.some((extension) => fs.existsSync(path.join(sourceBase, `index${extension}`)));
+            const directorySourceModule = this.hasSourceModule(path.join(sourceBase, 'index'));
+            if (directorySourceStyle || directorySourceModule) {
+                return {
+                    sourceDir: path.relative(this.srcRoot, sourceBase),
+                    styleEntry: directoryStyleEntry,
+                    hasOwnStyle: directorySourceStyle,
+                };
             }
             const hasFileSourceStyle = this.styleExtensions.some((extension) => fs.existsSync(`${sourceBase}${extension}`));
-            if (hasFileSourceStyle)
-                return path.join(sourceBase, 'style', 'index.css');
+            const hasFileSourceModule = this.hasSourceModule(sourceBase);
+            if (hasFileSourceStyle || hasFileSourceModule)
+                return {
+                    sourceDir: path.relative(this.srcRoot, sourceBase),
+                    styleEntry: path.join(sourceBase, 'style', 'index.css'),
+                    hasOwnStyle: hasFileSourceStyle,
+                };
         }
         return null;
     }
+    appendResolvedSourceImportStyles(entries, sourceImportEdges, acceptedSourceImportEdges) {
+        const styledSourceDirs = new Set(entries.keys());
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const [sourceModuleDir, edges] of sourceImportEdges) {
+                for (const edge of edges) {
+                    if (!edge.hasOwnStyle && !styledSourceDirs.has(edge.sourceDir)) {
+                        continue;
+                    }
+                    if (!this.addAcceptedSourceImportEdge(acceptedSourceImportEdges, sourceModuleDir, edge.sourceDir)) {
+                        continue;
+                    }
+                    const before = entries.get(sourceModuleDir)?.length ?? 0;
+                    appendUniqueMapValue(entries, sourceModuleDir, edge.specifier);
+                    const after = entries.get(sourceModuleDir)?.length ?? 0;
+                    if (after === before)
+                        continue;
+                    styledSourceDirs.add(sourceModuleDir);
+                    changed = true;
+                }
+            }
+        }
+    }
+    addAcceptedSourceImportEdge(edges, sourceDir, targetDir) {
+        if (sourceDir === targetDir)
+            return false;
+        if (this.hasSourceImportPath(edges, targetDir, sourceDir))
+            return false;
+        const targets = edges.get(sourceDir) ?? new Set();
+        targets.add(targetDir);
+        edges.set(sourceDir, targets);
+        return true;
+    }
+    hasSourceImportPath(edges, fromDir, toDir, seen = new Set()) {
+        if (fromDir === toDir)
+            return true;
+        if (seen.has(fromDir))
+            return false;
+        seen.add(fromDir);
+        for (const nextDir of edges.get(fromDir) ?? []) {
+            if (this.hasSourceImportPath(edges, nextDir, toDir, seen))
+                return true;
+        }
+        return false;
+    }
+    hasSourceModule(sourceBase) {
+        return fs.existsSync(`${sourceBase}${SOURCE_MODULE_EXTENSION}`);
+    }
     isInsideSourceRoot(file) {
         const relative = path.relative(this.srcRoot, file);
         return !relative.startsWith('..') && !path.isAbsolute(relative);

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

@@ -7,6 +7,7 @@ export declare class AukletStyleHmr {
     private readonly virtualIdsByDependency;
     constructor(graph: () => ModuleStyleGraph);
     trackVirtualStyleDependency(file: string, virtualId: string): void;
+    hasTrackedStyleDependency(file: string): boolean;
     installFullReloadGuard(server: Pick<ViteDevServer, 'ws'>): void;
     handleStyleHotUpdate(context: HotUpdateOptions): never[] | undefined;
     handleSourceModuleChange(server: Pick<ViteDevServer, 'moduleGraph' | 'ws'>, file: string): boolean;

package/dist/css/vite/hmr.js

@@ -50,6 +50,9 @@ export class AukletStyleHmr {
     trackVirtualStyleDependency(file, virtualId) {
         addVirtualStyleDependency(this.virtualIdsByDependency, file, virtualId);
     }
+    hasTrackedStyleDependency(file) {
+        return (getDependencyVirtualIds(this.virtualIdsByDependency, file).length > 0);
+    }
     installFullReloadGuard(server) {
         const send = server.ws.send.bind(server.ws);
         server.ws.send = ((payload, data) => {

package/dist/css/vite/vitePlugin.js

@@ -115,21 +115,24 @@ export function aukletStylePlugin(options = {}) {
                     return;
                 server.ws.send({ type: 'full-reload' });
             };
-            const handleSourceAddOrUnlink = (file) => {
-                if (graph.isStyleFile(file)) {
-                    reloadStyleGraph(file);
-                    return;
-                }
-                reloadStyleGraph(file);
-            };
-            server.watcher.on('add', handleSourceAddOrUnlink);
-            server.watcher.on('unlink', handleSourceAddOrUnlink);
+            server.watcher.on('add', reloadStyleGraph);
+            server.watcher.on('unlink', reloadStyleGraph);
             server.watcher.on('change', (file) => {
                 if (graph.isStyleConfigFile(file)) {
                     reloadStyleGraph(file);
-                    return;
                 }
-                if (graph.isSourceModuleFile(file)) {
+                else if (graph.isStyleFile(file) &&
+                    hmr.hasTrackedStyleDependency(file)) {
+                    hmr.handleStyleHotUpdate({
+                        file,
+                        modules: [],
+                        server,
+                        timestamp: Date.now(),
+                        type: 'update',
+                        read: async () => '',
+                    });
+                }
+                else if (graph.isSourceModuleFile(file)) {
                     hmr.handleSourceModuleChange(server, file);
                 }
             });

package/package.json

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