auklet 0.1.7 → 0.1.9

package/dist/cli/workspaceScripts.js

@@ -9,11 +9,11 @@ export async function resolveWorkspaceScriptTargets(cwd, filters, envContext, op
         excludeRoot: true,
         env: envContext.normalizedValues,
         scope: options.scope ?? 'workspace',
-        emptyTargetMessage: options.emptyTargetMessage ?? '[workspace] no workspace package found.',
         includePrivate: options.includePrivate,
         readPackageJson: readWorkspaceScriptPackageJson,
         getDependencies: getWorkspaceScriptDependencies,
         includeDependencies: options.includeDependencies,
+        emptyTargetMessage: options.emptyTargetMessage ?? '[workspace] no workspace package found.',
         createTarget: (item, packageJson) => ({
             packageRoot: item.path,
             packageName: item.name,

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

@@ -1,8 +1,8 @@
 import type { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 export type ModuleStyleEntryPlan = {
     sourceDir: string;
-    moduleStyleImports: Array<string>;
     ownStyleFiles: Array<string>;
+    moduleStyleImports: Array<string>;
 };
 export declare class StyleModuleEntryPlanner {
     private readonly packageContext;
@@ -23,4 +23,7 @@ export declare class StyleModuleEntryPlanner {
     private getSourceModuleDirs;
     private getOwnStyleDirs;
     private getOwnStyleFiles;
+    private rejectCrossModuleStyleImports;
+    private getStyleFileModuleDir;
+    private toRelativeSourceFile;
 }

package/dist/css/core/styleModuleEntryPlanner.js

@@ -11,6 +11,7 @@ export class StyleModuleEntryPlanner {
         this.styleFilesByDir = groupStyleFilesByDir(this.packageContext.sourceRoot, this.packageContext.styleFiles);
         this.importedStyleFiles =
             this.packageContext.styleProcessor.collectImportedStyleFiles(this.packageContext.styleFiles);
+        this.rejectCrossModuleStyleImports();
     }
     createEntries(moduleStyleImports) {
         return this.getSourceDirs(moduleStyleImports).map((sourceDir) => this.createEntry(sourceDir, moduleStyleImports));
@@ -47,4 +48,38 @@ export class StyleModuleEntryPlanner {
     getOwnStyleFiles(sourceDir) {
         return (this.styleFilesByDir.get(sourceDir) ?? []).filter((styleFile) => !this.importedStyleFiles.has(path.resolve(styleFile)));
     }
+    rejectCrossModuleStyleImports() {
+        if (!this.packageContext.normalizedConfig.modules)
+            return;
+        const styleFileKeys = new Set(this.packageContext.styleFiles.map((file) => path.resolve(file)));
+        const imports = this.packageContext.styleProcessor.collectImportedStyleFileReferences(this.packageContext.styleFiles);
+        for (const item of imports) {
+            if (!styleFileKeys.has(item.imported))
+                continue;
+            const importerModuleDir = this.getStyleFileModuleDir(item.importer);
+            const importedModuleDir = this.getStyleFileModuleDir(item.imported);
+            if (!importerModuleDir ||
+                !importedModuleDir ||
+                importerModuleDir === importedModuleDir) {
+                continue;
+            }
+            const importer = this.toRelativeSourceFile(item.importer);
+            const imported = this.toRelativeSourceFile(item.imported);
+            throw new Error(`[css] cross-component CSS import detected: ${importer} imports ${imported}. ` +
+                'Use TSX imports to express component dependencies so auklet can ' +
+                'generate module CSS entries correctly.');
+        }
+    }
+    getStyleFileModuleDir(file) {
+        const sourceRelative = toPosixPath(path.relative(this.packageContext.sourceRoot, file));
+        const parts = sourceRelative.split('/');
+        if (parts.length < 2)
+            return null;
+        if (parts.length === 2)
+            return getSourceModuleDir(sourceRelative);
+        return parts.slice(0, 2).join('/');
+    }
+    toRelativeSourceFile(file) {
+        return toPosixPath(path.relative(this.packageContext.sourceRoot, file));
+    }
 }

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

@@ -1,6 +1,10 @@
 import postcss, { type Root } from 'postcss';
 import type { ModuleStyleBuildConfig } from '#auklet/types';
 import type { WorkspaceStyleResolver } from '#auklet/css/core/workspaceStyleResolver';
+export type StyleFileImportReference = {
+    importer: string;
+    imported: string;
+};
 export declare class StyleProcessor {
     private readonly config;
     private readonly resolver;
@@ -11,6 +15,7 @@ export declare class StyleProcessor {
     appendStyleContent(target: Root, content: string, from: string): void;
     readStyleFile(stylePath: string, seen?: Set<string>): string;
     collectImportedStyleFiles(styleFiles: Array<string>): Set<string>;
+    collectImportedStyleFileReferences(styleFiles: Array<string>): StyleFileImportReference[];
     collectStyleImportSpecifiers(styleFiles: Array<string>): Set<string>;
     private parse;
     private parseImportSpecifier;

package/dist/css/core/styleProcessor.js

@@ -62,7 +62,10 @@ export class StyleProcessor {
         return root.toString();
     }
     collectImportedStyleFiles(styleFiles) {
-        const imported = new Set();
+        return new Set(this.collectImportedStyleFileReferences(styleFiles).map((item) => item.imported));
+    }
+    collectImportedStyleFileReferences(styleFiles) {
+        const imports = [];
         for (const styleFile of styleFiles) {
             const css = fs.readFileSync(styleFile, 'utf8');
             const root = this.parse(css, styleFile);
@@ -72,10 +75,13 @@ export class StyleProcessor {
                     !this.config.styleExtensions.includes(path.extname(specifier))) {
                     return;
                 }
-                imported.add(path.resolve(path.dirname(styleFile), specifier));
+                imports.push({
+                    importer: path.resolve(styleFile),
+                    imported: path.resolve(path.dirname(styleFile), specifier),
+                });
             });
         }
-        return imported;
+        return imports;
     }
     collectStyleImportSpecifiers(styleFiles) {
         const specifiers = new Set();

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();
@@ -72,16 +59,16 @@ 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);
         for (const module of modules) {
             context.server.moduleGraph.invalidateModule(module);
         }
-        invalidateVirtualModules(context.server, graph);
         const updates = virtualIds.map((id) => {
             const browserPath = toBrowserVirtualPath(id);
             return {

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): {
@@ -18,5 +19,8 @@ export declare class ModuleStyleGraph {
         code: string;
         watchFiles: string[];
     }>;
-    private createRequestCache;
+    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,11 @@ export class ModuleStyleGraph {
                     styleExtensions: this.config.styleExtensions,
                     loadAukletConfig: this.loadAukletConfig,
                 });
+        this.requestCache = new ModuleStyleGraphRequestCache({
+            packageSource: this.packageSource,
+            config: this.config,
+            loadAukletConfig: this.loadAukletConfig,
+        });
     }
     parsePackageStyleId(id) {
         return parsePackageStyleId(id, this.getPackageNames());
@@ -49,13 +56,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/requestCache.d.ts

@@ -62,5 +62,6 @@ export declare class ModuleStyleGraphRequestCache {
         sourceRoot: string;
         styleProcessor: StyleProcessor;
     } | null>;
+    invalidatePackage(packageName: string): void;
     private createContext;
 }

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

@@ -24,6 +24,9 @@ export class ModuleStyleGraphRequestCache {
         this.contexts.set(parsed.packageName, context);
         return context;
     }
+    invalidatePackage(packageName) {
+        this.contexts.delete(packageName);
+    }
     async createContext(parsed) {
         const stylePackage = this.options.packageSource
             .getPackages()

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)) {
+                    reloadStyleGraph(file);
                 }
             });
         },

package/package.json

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