auklet 0.3.3 → 0.3.4

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

@@ -29,6 +29,8 @@ export declare class StylePackageContext {
     constructor(options: StylePackageContextOptions);
     getStyleFiles(files: Array<string>): string[];
     getModuleStyleImports(): Map<string, string[]>;
+    invalidateModuleStyleImports(): void;
+    invalidateStyleContentCaches(): void;
     getModuleStyleEntryPlanner(): StyleModuleEntryPlanner;
     getStyleEntryFiles(): string[];
     isSharedStyleFile(file: string): boolean;

package/dist/css/core/stylePackageContext.js

@@ -59,6 +59,15 @@ export class StylePackageContext {
         this.moduleStyleImports ??= this.importCollector.collect(this.sourceFiles, this.normalizedConfig);
         return this.moduleStyleImports;
     }
+    invalidateModuleStyleImports() {
+        this.moduleStyleImports = undefined;
+        this.moduleStyleEntryPlanner = undefined;
+    }
+    invalidateStyleContentCaches() {
+        this.moduleStyleEntryPlanner = undefined;
+        this.hasValidatedSourceRootLocalStyleImports = false;
+        this.hasValidatedPreservedLocalStyleImports = false;
+    }
     getModuleStyleEntryPlanner() {
         this.moduleStyleEntryPlanner ??= new StyleModuleEntryPlanner(this);
         return this.moduleStyleEntryPlanner;

package/dist/css/production/builder.d.ts

@@ -1,9 +1,13 @@
+import { StylePackageContext } from '#auklet/css/core/stylePackageContext';
 import type { ModuleStyleBuildConfig, ModuleStyleBuildContext, ModuleStyleBuildOptions } from '#auklet/types';
+type ModuleStyleBuildInternalOptions = ModuleStyleBuildOptions & {
+    packageContext?: StylePackageContext;
+};
 export declare class ModuleStyleBuilder {
     private readonly config;
     private readonly context;
     constructor(context?: ModuleStyleBuildContext, config?: ModuleStyleBuildConfig);
-    build(options?: ModuleStyleBuildOptions): Promise<{
+    build(options?: ModuleStyleBuildInternalOptions): Promise<{
         packageRoot: string;
         styleFiles: string[];
         outputs: {
@@ -11,6 +15,8 @@ export declare class ModuleStyleBuilder {
             size: number;
         }[];
     }>;
+    createPackageContext(options?: ModuleStyleBuildOptions): StylePackageContext;
     private createBuildContext;
-    private createPackageContext;
+    private createStylePackageContext;
 }
+export {};

package/dist/css/production/builder.js

@@ -20,7 +20,8 @@ export class ModuleStyleBuilder {
         const rawConfig = options.aukletConfig ?? this.context.aukletConfig ?? {};
         const normalizedConfig = normalizeAukletConfig(rawConfig);
         const context = this.createBuildContext(normalizedConfig);
-        const packageContext = this.createPackageContext(context, normalizedConfig);
+        const packageContext = options.packageContext ??
+            this.createStylePackageContext(context, normalizedConfig);
         packageContext.assertNoSourceRootEscapingLocalStyleImports();
         const writerOptions = {
             config: this.config,
@@ -42,6 +43,12 @@ export class ModuleStyleBuilder {
             })),
         };
     }
+    createPackageContext(options = {}) {
+        const rawConfig = options.aukletConfig ?? this.context.aukletConfig ?? {};
+        const normalizedConfig = normalizeAukletConfig(rawConfig);
+        const context = this.createBuildContext(normalizedConfig);
+        return this.createStylePackageContext(context, normalizedConfig);
+    }
     createBuildContext(config) {
         return {
             packageRoot: this.context.packageRoot,
@@ -49,7 +56,7 @@ export class ModuleStyleBuilder {
             outputDir: this.context.output ?? config.output,
         };
     }
-    createPackageContext(context, normalizedConfig) {
+    createStylePackageContext(context, normalizedConfig) {
         return new StylePackageContext({
             config: this.config,
             context,

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

@@ -37,7 +37,6 @@ export declare class AukletStyleHmr {
     private sameStyleLoadResult;
     private suppressFullReload;
     private shouldSuppressFullReload;
-    private logDebug;
     private isDuplicateUpdate;
 }
 export {};

package/dist/css/vite/hmr.js

@@ -129,18 +129,12 @@ export class AukletStyleHmr {
         if (!graph.isStyleFile(context.file)) {
             return undefined;
         }
-        const totalStartedAt = Date.now();
         const isSourceGraphFile = graph.isSourceGraphFile(context.file);
         const trackedEntries = this.getTrackedStyleFileEntries(context.file, context.server.moduleGraph);
-        const debug = trackedEntries.length
-            ? await graph.isDebugEnabled(trackedEntries[0].parsed)
-            : false;
-        this.logDebug(debug, `package css hmr start ${getRelativeFile(context.file)} tracked=${trackedEntries.length}`);
         if (!trackedEntries.length) {
             if (isSourceGraphFile) {
                 graph.invalidateFile(context.file);
             }
-            this.logDebug(debug, `package css hmr skip ${getRelativeFile(context.file)} total=${Date.now() - totalStartedAt}ms`);
             return undefined;
         }
         const entryEntries = isSourceGraphFile
@@ -153,7 +147,7 @@ export class AukletStyleHmr {
             ? this.createTrackedVirtualStyleResults(graph, entryEntries)
             : null;
         if (isSourceGraphFile) {
-            graph.invalidateFile(context.file);
+            graph.invalidateFileLoadResults(context.file);
         }
         else {
             this.invalidateTrackedVirtualPackages(graph, dependencyEntries);
@@ -161,16 +155,14 @@ export class AukletStyleHmr {
         if (this.isDuplicateUpdate(context.file)) {
             return [];
         }
-        const updates = [
-            ...(dependencyEntries.length
-                ? this.createTrackedVirtualStyleUpdates(context.server, dependencyEntries, context.timestamp)
-                : []),
-            ...(entryEntries.length
-                ? await this.refreshTrackedVirtualStyleUpdates(context.server, entryEntries, previousResults, context.timestamp, debug)
-                : []),
-        ];
+        const dependencyUpdates = dependencyEntries.length
+            ? this.createTrackedVirtualStyleUpdates(context.server, dependencyEntries, context.timestamp)
+            : [];
+        const entryUpdates = entryEntries.length
+            ? await this.refreshTrackedVirtualStyleUpdates(context.server, entryEntries, previousResults, context.timestamp)
+            : [];
+        const updates = [...dependencyUpdates, ...entryUpdates];
         if (!updates.length) {
-            this.logDebug(debug, `package css hmr no-update ${getRelativeFile(context.file)} total=${Date.now() - totalStartedAt}ms`);
             return undefined;
         }
         this.suppressFullReload();
@@ -179,7 +171,6 @@ export class AukletStyleHmr {
             updates,
         });
         logger.info(`package css hmr ${getRelativeFile(context.file)} tracked=${trackedEntries.length} updates=${updates.length}`);
-        this.logDebug(debug, `package css hmr done ${getRelativeFile(context.file)} tracked=${trackedEntries.length} updates=${updates.length} total=${Date.now() - totalStartedAt}ms`);
         return [];
     }
     async handleSourceModuleChange(server, file) {
@@ -187,25 +178,20 @@ export class AukletStyleHmr {
         if (!graph.isSourceGraphFile(file) || !graph.isSourceModuleFile(file)) {
             return false;
         }
-        const totalStartedAt = Date.now();
         const virtualIds = this.getDependencyVirtualIds(file, server.moduleGraph);
         if (!virtualIds.length) {
             graph.invalidateFile(file);
-            this.logDebug(false, `package css source hmr skip ${getRelativeFile(file)} reason=untracked total=${Date.now() - totalStartedAt}ms`);
             return false;
         }
         const parsedVirtualIds = this.parseTrackedVirtualIds(graph, virtualIds);
         if (!parsedVirtualIds.length) {
             graph.invalidateFile(file);
-            this.logDebug(false, `package css source hmr skip ${getRelativeFile(file)} reason=unparsed total=${Date.now() - totalStartedAt}ms`);
             return false;
         }
-        const debug = await graph.isDebugEnabled(parsedVirtualIds[0].parsed);
         const previousResults = this.createTrackedVirtualStyleResults(graph, parsedVirtualIds);
         graph.invalidateFile(file);
-        const updates = await this.refreshTrackedVirtualStyleUpdates(server, parsedVirtualIds, previousResults, Date.now(), debug);
+        const updates = await this.refreshTrackedVirtualStyleUpdates(server, parsedVirtualIds, previousResults, Date.now());
         if (!updates.length) {
-            this.logDebug(debug, `package css source hmr no-update ${getRelativeFile(file)} tracked=${parsedVirtualIds.length} total=${Date.now() - totalStartedAt}ms`);
             return false;
         }
         this.suppressFullReload();
@@ -214,7 +200,6 @@ export class AukletStyleHmr {
             updates,
         });
         logger.info(`package css source hmr ${getRelativeFile(file)} tracked=${parsedVirtualIds.length} updates=${updates.length}`);
-        this.logDebug(debug, `package css source hmr done ${getRelativeFile(file)} tracked=${parsedVirtualIds.length} updates=${updates.length} total=${Date.now() - totalStartedAt}ms`);
         return true;
     }
     parseTrackedVirtualIds(graph, virtualIds) {
@@ -309,13 +294,11 @@ export class AukletStyleHmr {
             kind,
         };
     }
-    async refreshTrackedVirtualStyleUpdates(server, parsedVirtualIds, previousResults, timestamp, debug) {
+    async refreshTrackedVirtualStyleUpdates(server, parsedVirtualIds, previousResults, timestamp) {
         const graph = this.graph();
         const changedVirtualIds = [];
         for (const item of parsedVirtualIds) {
-            const buildStartedAt = Date.now();
             const nextResult = await graph.createPackageStyleCode(item.parsed);
-            this.logDebug(debug, `package css hmr rebuild ${item.id} took=${Date.now() - buildStartedAt}ms`);
             const previousResult = previousResults.get(item.id);
             if (!previousResult ||
                 !this.sameStyleLoadResult(previousResult, nextResult)) {
@@ -339,11 +322,6 @@ export class AukletStyleHmr {
     shouldSuppressFullReload() {
         return Date.now() <= this.suppressFullReloadUntil;
     }
-    logDebug(enabled, message) {
-        if (!enabled)
-            return;
-        logger.info(message);
-    }
     isDuplicateUpdate(file) {
         const now = Date.now();
         const normalizedFile = normalizeFileKey(file);

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

@@ -17,9 +17,10 @@ export declare class ModuleStyleGraph {
     getWatchRoots(): Promise<string[]>;
     createPackageStyleCode(parsed: PackageStyleId): Promise<import("#auklet/css/vite/moduleGraph/types").PackageStyleLoadResult>;
     peekPackageStyleCode(parsed: PackageStyleId): import("#auklet/css/vite/moduleGraph/types").PackageStyleLoadResult | null;
-    isDebugEnabled(parsed: PackageStyleId): Promise<boolean>;
     invalidatePackage(packageName: string): void;
+    invalidateFileLoadResults(file: string): string | null;
     invalidateFile(file: string): string | null;
     isSourceModuleFile(file: string): boolean;
+    private getFilePackageName;
     private isPackageFile;
 }

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

@@ -63,26 +63,34 @@ export class ModuleStyleGraph {
     peekPackageStyleCode(parsed) {
         return this.requestCache.peekLoadResult(parsed);
     }
-    isDebugEnabled(parsed) {
-        return this.requestCache.isDebugEnabled(parsed);
-    }
     invalidatePackage(packageName) {
         this.requestCache.invalidatePackage(packageName);
     }
+    invalidateFileLoadResults(file) {
+        const packageName = this.getFilePackageName(file);
+        if (!packageName)
+            return null;
+        this.requestCache.invalidatePackageLoadResults(packageName);
+        return packageName;
+    }
     invalidateFile(file) {
+        const packageName = this.getFilePackageName(file);
+        if (!packageName)
+            return null;
+        this.invalidatePackage(packageName);
+        return packageName;
+    }
+    isSourceModuleFile(file) {
+        return SOURCE_MODULE_RE.test(normalizeFileKey(file));
+    }
+    getFilePackageName(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));
+        return stylePackage?.packageName ?? null;
     }
     isPackageFile(packageRoot, file) {
         const normalizedPackageRoot = normalizeFileKey(packageRoot);

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

@@ -28,6 +28,7 @@ export type ModuleStyleGraphRequestCacheOptions = {
 export declare class ModuleStyleGraphRequestCache {
     private readonly options;
     private readonly contexts;
+    private readonly settledContexts;
     private readonly loadResults;
     private readonly settledLoadResults;
     private readonly loadResultsByPackage;
@@ -80,8 +81,8 @@ export declare class ModuleStyleGraphRequestCache {
     } | null>;
     getLoadResult(parsed: PackageStyleId, create: () => Promise<LoadResultEntry>): Promise<PackageStyleLoadResult>;
     invalidatePackage(packageName: string): void;
+    invalidatePackageLoadResults(packageName: string): void;
     readPersistentLoadResult(parsed: PackageStyleId, context: PackageStyleContext): PackageStyleLoadResult | null;
-    isDebugEnabled(parsed: PackageStyleId): Promise<boolean>;
     writePersistentLoadResult(parsed: PackageStyleId, context: PackageStyleContext, result: PackageStyleLoadResult): {
         cacheInputFiles: string[];
         code: string;

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

@@ -7,6 +7,7 @@ import { normalizeFileKey, toPosixPath } from '#auklet/utils';
 export class ModuleStyleGraphRequestCache {
     options;
     contexts = new Map();
+    settledContexts = new Map();
     loadResults = new Map();
     settledLoadResults = new Map();
     loadResultsByPackage = new Map();
@@ -35,6 +36,20 @@ export class ModuleStyleGraphRequestCache {
             return cachedContext;
         const context = this.createContext(parsed);
         this.contexts.set(parsed.packageName, context);
+        context.then((resolvedContext) => {
+            if (this.contexts.get(parsed.packageName) !== context)
+                return;
+            if (resolvedContext) {
+                this.settledContexts.set(parsed.packageName, resolvedContext);
+            }
+            else {
+                this.settledContexts.delete(parsed.packageName);
+            }
+        }, () => {
+            if (this.contexts.get(parsed.packageName) !== context)
+                return;
+            this.settledContexts.delete(parsed.packageName);
+        });
         return context;
     }
     getLoadResult(parsed, create) {
@@ -91,15 +106,19 @@ export class ModuleStyleGraphRequestCache {
     invalidatePackage(packageName) {
         this.bumpGraphVersion();
         this.contexts.delete(packageName);
+        this.settledContexts.delete(packageName);
+        this.invalidateLoadResults(packageName);
+    }
+    invalidatePackageLoadResults(packageName) {
+        this.bumpGraphVersion();
+        this.settledContexts
+            .get(packageName)
+            ?.packageContext.invalidateStyleContentCaches();
         this.invalidateLoadResults(packageName);
     }
     readPersistentLoadResult(parsed, context) {
         return this.persistentCache.read(this.createPersistentKey(parsed, context));
     }
-    async isDebugEnabled(parsed) {
-        const context = await this.getContext(parsed);
-        return context?.normalizedConfig.debug ?? false;
-    }
     writePersistentLoadResult(parsed, context, result) {
         const cacheInputFiles = this.getPersistentInputFiles(context, result);
         const cacheResult = {

package/dist/css/vite/vitePlugin.js

@@ -150,7 +150,8 @@ export function aukletStylePlugin(options = {}) {
                         reloadStyleGraph(file);
                     }
                     else if (graph.isStyleFile(file)) {
-                        if (hmr.hasTrackedStyleDependency(file)) {
+                        const tracked = hmr.hasTrackedStyleDependency(file);
+                        if (tracked) {
                             await hmr.handleStyleHotUpdate({
                                 file,
                                 modules: [],
@@ -161,7 +162,7 @@ export function aukletStylePlugin(options = {}) {
                             });
                         }
                         else {
-                            graph.invalidateFile(file);
+                            graph.invalidateFileLoadResults(file);
                         }
                     }
                     else if (graph.isSourceModuleFile(file)) {

package/dist/css/watch/watcher.d.ts

@@ -1,6 +1,6 @@
 import { type AukletLogger } from '#auklet/logger';
 import type { ModuleStyleBuildConfig, ModuleStyleBuildContext } from '#auklet/types';
-type ModuleStyleWatcherLogger = Pick<AukletLogger, 'error'> & Partial<Pick<AukletLogger, 'info'>>;
+type ModuleStyleWatcherLogger = Pick<AukletLogger, 'error'>;
 export declare class ModuleStyleWatcher {
     private readonly context;
     private readonly config;
@@ -11,14 +11,16 @@ export declare class ModuleStyleWatcher {
     private shouldRebuild;
     private watcher;
     private readonly lastErrorLogTimes;
+    private packageContext;
     constructor(context?: ModuleStyleBuildContext, config?: ModuleStyleBuildConfig, logger?: ModuleStyleWatcherLogger | null);
     watch(): Promise<void>;
     private rebuild;
-    private logDebug;
     private refreshWatcher;
     private logError;
     private scheduleBuild;
     private shouldRebuildForFile;
+    private handleFileEvent;
+    private invalidateBuildCache;
     close(): Promise<void>;
 }
 export {};

package/dist/css/watch/watcher.js

@@ -18,6 +18,7 @@ export class ModuleStyleWatcher {
     shouldRebuild = false;
     watcher = null;
     lastErrorLogTimes = new Map();
+    packageContext = null;
     constructor(context = {}, config = moduleStyleBuildConfig, logger = null) {
         this.context = {
             packageRoot: process.cwd(),
@@ -39,12 +40,16 @@ export class ModuleStyleWatcher {
             return;
         }
         this.isBuilding = true;
-        const startedAt = Date.now();
         try {
             try {
                 const builder = new ModuleStyleBuilder(this.context, this.config);
-                await builder.build();
-                this.logDebug(`CSS build finished in ${Date.now() - startedAt}ms`);
+                this.packageContext ??= builder.createPackageContext({
+                    aukletConfig: this.context.aukletConfig,
+                });
+                await builder.build({
+                    aukletConfig: this.context.aukletConfig,
+                    packageContext: this.packageContext,
+                });
             }
             catch (error) {
                 this.logError('build', 'CSS build failed; waiting for changes.', error);
@@ -66,11 +71,6 @@ export class ModuleStyleWatcher {
             }
         }
     }
-    logDebug(message) {
-        if (this.context.aukletConfig?.debug !== true)
-            return;
-        this.logger.info?.(message);
-    }
     async refreshWatcher() {
         if (this.closed)
             return;
@@ -89,13 +89,8 @@ export class ModuleStyleWatcher {
             interval: 300,
             usePolling: true,
         });
-        this.watcher.on('all', (_event, file) => {
-            if (this.closed)
-                return;
-            if (isString(file) && !this.shouldRebuildForFile(file)) {
-                return;
-            }
-            this.scheduleBuild();
+        this.watcher.on('all', (event, file) => {
+            this.handleFileEvent(event, file);
         });
         this.watcher.on('error', (error) => {
             if (this.closed)
@@ -130,6 +125,34 @@ export class ModuleStyleWatcher {
             return true;
         return this.config.styleExtensions.includes(path.extname(file));
     }
+    handleFileEvent(event, file) {
+        if (this.closed || !isString(file))
+            return;
+        if (!this.shouldRebuildForFile(file))
+            return;
+        this.invalidateBuildCache(event, file);
+        this.scheduleBuild();
+    }
+    invalidateBuildCache(event, file) {
+        if (isAukletConfigFile(path.basename(file))) {
+            this.packageContext = null;
+            return;
+        }
+        if (event === 'add' ||
+            event === 'unlink' ||
+            event === 'addDir' ||
+            event === 'unlinkDir') {
+            this.packageContext = null;
+            return;
+        }
+        if (SOURCE_MODULE_RE.test(file)) {
+            this.packageContext?.invalidateModuleStyleImports();
+            return;
+        }
+        if (this.config.styleExtensions.includes(path.extname(file))) {
+            this.packageContext?.invalidateStyleContentCaches();
+        }
+    }
     async close() {
         this.closed = true;
         this.shouldRebuild = false;

package/package.json

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