auklet 0.3.2 → 0.3.4

package/dist/build/cliOverrides.d.ts

@@ -15,6 +15,7 @@ export declare function mergeAukletConfigOverrides(config: AukletConfig, overrid
         configureTsdown?: import("#auklet/types").ConfigureTsdown;
         tsconfig?: string;
     } | undefined;
+    debug?: boolean;
     source?: string;
     output?: string;
     modules?: boolean;

package/dist/cli/help.js

@@ -1,4 +1,8 @@
 export const buildOverrideOptions = [
+    [
+        '--debug [value]',
+        'Enable debug logging for package CSS build, watch, and HMR flows',
+    ],
     ['--source <dir>', 'Source directory'],
     ['--output <dir>', 'Output directory'],
     ['--modules [value]', 'Enable unbundled module output'],

package/dist/cli/parse/build.js

@@ -54,6 +54,16 @@ export function parseBuildOverrideArgs(args, envContext) {
                 index += 1;
             continue;
         }
+        if (name === '--debug') {
+            const value = readOptionalFlagValue(args, index, inlineValue);
+            config.debug =
+                value === undefined
+                    ? true
+                    : resolveCliBoolean(value, { label: name, context: envContext });
+            if (inlineValue === undefined && value !== undefined)
+                index += 1;
+            continue;
+        }
         if (name === '--output') {
             config.output = getResolvedFlagValue(args, index, inlineValue, name, envContext);
             if (inlineValue === undefined)

package/dist/config.d.ts

@@ -2,6 +2,7 @@ import type { AukletConfig } from '#auklet/types';
 export declare const aukletConfigFiles: string[];
 export declare function isAukletConfigFile(file: string): boolean;
 export declare const aukletDefaultOptions: {
+    debug: false;
     source: string;
     output: string;
     modules: false;
@@ -17,6 +18,7 @@ export declare const aukletDefaultOptions: {
     };
 };
 export declare function normalizeAukletConfig(config?: AukletConfig): {
+    debug: boolean;
     source: string;
     output: string;
     modules: boolean;

package/dist/config.js

@@ -4,6 +4,7 @@ export function isAukletConfigFile(file) {
     return aukletConfigFiles.includes(file);
 }
 export const aukletDefaultOptions = {
+    debug: false,
     source: 'src',
     output: 'dist',
     modules: false,
@@ -40,6 +41,7 @@ const normalizeStyleShared = (shared) => {
 export function normalizeAukletConfig(config = {}) {
     const dependencies = config.styles?.dependencies ?? aukletDefaultOptions.styles.dependencies;
     return {
+        debug: config.debug ?? aukletDefaultOptions.debug,
         source: config.source ?? aukletDefaultOptions.source,
         output: config.output ?? aukletDefaultOptions.output,
         modules: config.modules ?? aukletDefaultOptions.modules,

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/inspect.d.ts

@@ -47,6 +47,7 @@ export declare function resolveInspectCssOptions(args: Array<string>): Promise<{
                 configureTsdown?: import("#auklet/types").ConfigureTsdown;
                 tsconfig?: string;
             } | undefined;
+            debug?: boolean;
             source?: string;
             output?: string;
             modules?: boolean;

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.js

@@ -147,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);
@@ -155,14 +155,13 @@ 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)
-                : []),
-        ];
+        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) {
             return undefined;
         }

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

@@ -18,7 +18,9 @@ export declare class ModuleStyleGraph {
     createPackageStyleCode(parsed: PackageStyleId): Promise<import("#auklet/css/vite/moduleGraph/types").PackageStyleLoadResult>;
     peekPackageStyleCode(parsed: PackageStyleId): import("#auklet/css/vite/moduleGraph/types").PackageStyleLoadResult | null;
     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

@@ -66,20 +66,31 @@ export class ModuleStyleGraph {
     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;
@@ -45,6 +46,7 @@ export declare class ModuleStyleGraphRequestCache {
         configPaths: string[];
         packageContext: StylePackageContext;
         normalizedConfig: {
+            debug: boolean;
             source: string;
             output: string;
             modules: boolean;
@@ -79,6 +81,7 @@ 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;
     writePersistentLoadResult(parsed: PackageStyleId, context: PackageStyleContext, result: PackageStyleLoadResult): {
         cacheInputFiles: 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,6 +106,14 @@ 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) {

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

@@ -11,6 +11,7 @@ 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;
@@ -18,6 +19,8 @@ export declare class ModuleStyleWatcher {
     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(),
@@ -42,7 +43,13 @@ export class ModuleStyleWatcher {
         try {
             try {
                 const builder = new ModuleStyleBuilder(this.context, this.config);
-                await builder.build();
+                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);
@@ -82,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)
@@ -123,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/dist/types.d.ts

@@ -15,6 +15,7 @@ export type NormalizedStyleDependencyGroup = {
     components?: string | Array<string>;
 };
 export interface NormalizedAukletConfig {
+    debug: boolean;
     source: string;
     output: string;
     modules: boolean;
@@ -49,6 +50,7 @@ export type PackageBuildOptions = {
     tsconfig?: string;
 };
 export interface AukletConfig {
+    debug?: boolean;
     source?: string;
     output?: string;
     modules?: boolean;

package/package.json

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