auklet 0.3.1 → 0.3.3

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

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

package/dist/css/vite/hmr.js

@@ -129,12 +129,18 @@ 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
@@ -160,10 +166,11 @@ export class AukletStyleHmr {
                 ? this.createTrackedVirtualStyleUpdates(context.server, dependencyEntries, context.timestamp)
                 : []),
             ...(entryEntries.length
-                ? await this.refreshTrackedVirtualStyleUpdates(context.server, entryEntries, previousResults, context.timestamp)
+                ? await this.refreshTrackedVirtualStyleUpdates(context.server, entryEntries, previousResults, context.timestamp, debug)
                 : []),
         ];
         if (!updates.length) {
+            this.logDebug(debug, `package css hmr no-update ${getRelativeFile(context.file)} total=${Date.now() - totalStartedAt}ms`);
             return undefined;
         }
         this.suppressFullReload();
@@ -172,6 +179,7 @@ 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) {
@@ -179,20 +187,25 @@ 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());
+        const updates = await this.refreshTrackedVirtualStyleUpdates(server, parsedVirtualIds, previousResults, Date.now(), debug);
         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();
@@ -201,6 +214,7 @@ 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) {
@@ -295,11 +309,13 @@ export class AukletStyleHmr {
             kind,
         };
     }
-    async refreshTrackedVirtualStyleUpdates(server, parsedVirtualIds, previousResults, timestamp) {
+    async refreshTrackedVirtualStyleUpdates(server, parsedVirtualIds, previousResults, timestamp, debug) {
         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)) {
@@ -323,6 +339,11 @@ 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,6 +17,7 @@ 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;
     invalidateFile(file: string): string | null;
     isSourceModuleFile(file: string): boolean;

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

@@ -63,6 +63,9 @@ export class ModuleStyleGraph {
     peekPackageStyleCode(parsed) {
         return this.requestCache.peekLoadResult(parsed);
     }
+    isDebugEnabled(parsed) {
+        return this.requestCache.isDebugEnabled(parsed);
+    }
     invalidatePackage(packageName) {
         this.requestCache.invalidatePackage(packageName);
     }

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;
@@ -43,6 +45,7 @@ export declare class ModuleStyleGraphRequestCache {
         configPaths: string[];
         packageContext: StylePackageContext;
         normalizedConfig: {
+            debug: boolean;
             source: string;
             output: string;
             modules: boolean;
@@ -78,6 +81,7 @@ export declare class ModuleStyleGraphRequestCache {
     getLoadResult(parsed: PackageStyleId, create: () => Promise<LoadResultEntry>): Promise<PackageStyleLoadResult>;
     invalidatePackage(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;
@@ -100,5 +104,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?.();
@@ -93,6 +96,10 @@ export class ModuleStyleGraphRequestCache {
     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 = {
@@ -226,39 +233,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 +289,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/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'>;
+type ModuleStyleWatcherLogger = Pick<AukletLogger, 'error'> & Partial<Pick<AukletLogger, 'info'>>;
 export declare class ModuleStyleWatcher {
     private readonly context;
     private readonly config;
@@ -14,6 +14,7 @@ export declare class ModuleStyleWatcher {
     constructor(context?: ModuleStyleBuildContext, config?: ModuleStyleBuildConfig, logger?: ModuleStyleWatcherLogger | null);
     watch(): Promise<void>;
     private rebuild;
+    private logDebug;
     private refreshWatcher;
     private logError;
     private scheduleBuild;

package/dist/css/watch/watcher.js

@@ -39,10 +39,12 @@ 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`);
             }
             catch (error) {
                 this.logError('build', 'CSS build failed; waiting for changes.', error);
@@ -64,6 +66,11 @@ export class ModuleStyleWatcher {
             }
         }
     }
+    logDebug(message) {
+        if (this.context.aukletConfig?.debug !== true)
+            return;
+        this.logger.info?.(message);
+    }
     async refreshWatcher() {
         if (this.closed)
             return;

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.1",
+  "version": "0.3.3",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",