auklet 0.2.0 → 0.2.2

package/dist/configLoader.js

@@ -6,6 +6,7 @@ import { aukletConfigFiles, isAukletConfigFile } from '#auklet/config';
 const asRecord = (value) => {
     return isPlainObject(value) ? value : null;
 };
+let configImportVersion = 0;
 const assertSupportedConfigFile = (configFile) => {
     const basename = path.basename(configFile);
     if (isAukletConfigFile(basename))
@@ -53,7 +54,8 @@ export async function loadAukletConfig(packageRoot, options = {}) {
     }
     const url = pathToFileURL(configPath);
     if (options.cacheBust) {
-        url.searchParams.set('t', Date.now().toString());
+        configImportVersion += 1;
+        url.searchParams.set('t', configImportVersion.toString());
     }
     const module = (await import(url.href));
     return resolveAukletConfigModule(module);

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

@@ -1,8 +1,10 @@
 import type { PackageStyleContext } from '#auklet/css/vite/moduleGraph/requestCache';
 export declare function toDevDependencyImportSpecifier(context: PackageStyleContext, specifier: string): {
     specifier: string;
+    cacheInputFiles?: undefined;
     watchFile?: undefined;
 } | {
+    cacheInputFiles: string[];
     specifier: string;
     watchFile: string;
 };

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

@@ -1,11 +1,62 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { toFsSpecifier } from '#auklet/utils';
+const getPackageName = (specifier) => {
+    if (!specifier.startsWith('@'))
+        return specifier.split('/')[0] ?? specifier;
+    const [scope, name] = specifier.split('/');
+    if (!scope || !name)
+        return null;
+    return `${scope}/${name}`;
+};
+const findNodeModulesPackageRoot = (file, packageName) => {
+    const resolved = path.resolve(file);
+    const root = path.parse(resolved).root;
+    const parts = path.relative(root, resolved).split(path.sep);
+    const packageParts = packageName.split('/');
+    const packageLength = packageParts.length;
+    for (let index = parts.length - packageLength - 1; index >= 0; index -= 1) {
+        if (parts[index] !== 'node_modules')
+            continue;
+        const candidateParts = parts.slice(index + 1, index + 1 + packageLength);
+        if (candidateParts.join('/') !== packageName)
+            continue;
+        return path.join(root, ...parts.slice(0, index + 1 + packageLength));
+    }
+    return null;
+};
+const findPackageJson = (file, context, specifier) => {
+    const packageName = getPackageName(specifier);
+    if (!packageName)
+        return null;
+    const packageRoot = findNodeModulesPackageRoot(file, packageName);
+    if (!packageRoot) {
+        return path.join(context.context.packageRoot, 'node_modules', packageName, 'package.json');
+    }
+    let current = path.dirname(file);
+    let next = current;
+    const packageRootKey = path.resolve(packageRoot);
+    do {
+        const packageJson = path.join(current, 'package.json');
+        if (fs.existsSync(packageJson))
+            return packageJson;
+        if (path.resolve(current) === packageRootKey)
+            break;
+        next = path.dirname(current);
+        if (next !== current)
+            current = next;
+    } while (next !== current);
+    return path.join(context.context.packageRoot, 'node_modules', packageName, 'package.json');
+};
 // 在 Vite 虚拟 CSS 中，第三方 CSS 依赖要用声明它的包作为解析根。
 export function toDevDependencyImportSpecifier(context, specifier) {
     if (specifier.startsWith('.') || specifier.startsWith('/')) {
         return { specifier };
     }
     const resolved = context.resolver.resolveStyleDependency(specifier);
+    const packageJson = findPackageJson(resolved, context, specifier);
     return {
+        cacheInputFiles: packageJson ? [packageJson] : [],
         specifier: toFsSpecifier(resolved),
         watchFile: resolved,
     };

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

@@ -3,11 +3,13 @@ export type PersistentStyleGraphCacheOptions = {
     root: string;
 };
 export declare class PersistentStyleGraphCache {
+    private static readonly cleanedRoots;
     private readonly cacheRoot;
     constructor(options: PersistentStyleGraphCacheOptions);
     createKey(value: unknown): string;
     read(key: string): PackageStyleLoadResult | null;
     write(key: string, result: PackageStyleLoadResult, inputFiles: Array<string>): void;
+    private cleanupStaleEntries;
     private getCacheFile;
     private isFresh;
 }

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

@@ -3,6 +3,8 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 import { toPosixPath } from '#auklet/utils';
 const cacheVersion = 'v1';
+const maxCacheFiles = 5000;
+const staleCacheAgeMs = 7 * 24 * 60 * 60 * 1000;
 const stableStringify = (value) => {
     if (Array.isArray(value)) {
         return `[${value.map((item) => stableStringify(item)).join(',')}]`;
@@ -66,6 +68,7 @@ const statCachedFile = (file) => {
     };
 };
 export class PersistentStyleGraphCache {
+    static cleanedRoots = new Set();
     cacheRoot;
     constructor(options) {
         this.cacheRoot = path.join(options.root, 'node_modules', '.auklet', 'cache', 'vite-style', cacheVersion);
@@ -106,6 +109,45 @@ export class PersistentStyleGraphCache {
         }
         catch {
             // Cache writes are an optimization; dev CSS generation must keep working.
+            return;
+        }
+        this.cleanupStaleEntries();
+    }
+    cleanupStaleEntries() {
+        if (PersistentStyleGraphCache.cleanedRoots.has(this.cacheRoot))
+            return;
+        PersistentStyleGraphCache.cleanedRoots.add(this.cacheRoot);
+        try {
+            const now = Date.now();
+            const entries = fs
+                .readdirSync(this.cacheRoot, { withFileTypes: true })
+                .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+                .map((entry) => {
+                const file = path.join(this.cacheRoot, entry.name);
+                return {
+                    file,
+                    mtimeMs: fs.statSync(file).mtimeMs,
+                };
+            });
+            const freshEntries = [];
+            for (const entry of entries) {
+                if (now - entry.mtimeMs > staleCacheAgeMs) {
+                    fs.unlinkSync(entry.file);
+                    continue;
+                }
+                freshEntries.push(entry);
+            }
+            const overflowCount = freshEntries.length - maxCacheFiles;
+            if (overflowCount <= 0)
+                return;
+            for (const entry of freshEntries
+                .sort((left, right) => left.mtimeMs - right.mtimeMs)
+                .slice(0, overflowCount)) {
+                fs.unlinkSync(entry.file);
+            }
+        }
+        catch {
+            // Cache cleanup is best-effort and must not affect dev CSS generation.
         }
     }
     getCacheFile(key) {

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

@@ -79,6 +79,8 @@ export declare class ModuleStyleGraphRequestCache {
     private createContext;
     private createPersistentKey;
     private getPersistentInputFiles;
+    private getPackageKeyEntries;
+    private getWorkspaceInputFiles;
     private getSourceInputFiles;
     private getResolutionInputFiles;
     private getLoadResultKey;

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

@@ -57,6 +57,8 @@ export class ModuleStyleGraphRequestCache {
             ...result,
             cacheInputFiles,
         };
+        if (!result.code.trim())
+            return cacheResult;
         this.persistentCache.write(this.createPersistentKey(parsed, context), cacheResult, cacheInputFiles);
         return cacheResult;
     }
@@ -103,6 +105,7 @@ export class ModuleStyleGraphRequestCache {
             normalizedConfig: context.normalizedConfig,
             packageName: context.packageName,
             packageNames: this.getPackageNames(),
+            packages: this.getPackageKeyEntries(),
             packageRoot: normalizeFileKey(context.context.packageRoot),
             parsed,
             root: normalizeFileKey(this.options.root),
@@ -116,21 +119,42 @@ export class ModuleStyleGraphRequestCache {
             ...(result.cacheInputFiles ?? []),
             ...this.getSourceInputFiles(context.sourceRoot, context.packageContext.sourceFiles),
             ...this.getResolutionInputFiles(context.context.packageRoot),
+            ...this.getWorkspaceInputFiles(),
         ];
     }
+    getPackageKeyEntries() {
+        return this.options.packageSource
+            .getPackages()
+            .map((item) => ({
+            packageName: item.packageName,
+            packageRoot: normalizeFileKey(item.packageRoot),
+        }))
+            .sort((left, right) => {
+            const nameOrder = left.packageName.localeCompare(right.packageName);
+            if (nameOrder !== 0)
+                return nameOrder;
+            return left.packageRoot.localeCompare(right.packageRoot);
+        });
+    }
+    getWorkspaceInputFiles() {
+        if (this.options.mode !== 'monorepo')
+            return [];
+        return [path.join(this.options.root, 'pnpm-workspace.yaml')];
+    }
     getSourceInputFiles(sourceRoot, sourceFiles) {
         const sourceInputFiles = new Set([sourceRoot, ...sourceFiles]);
         const normalizedSourceRoot = normalizeFileKey(sourceRoot);
         for (const file of sourceFiles) {
             let current = path.dirname(file);
-            while (true) {
+            let currentKey = normalizeFileKey(current);
+            while (currentKey === normalizedSourceRoot ||
+                currentKey.startsWith(`${normalizedSourceRoot}/`)) {
                 sourceInputFiles.add(current);
-                if (normalizeFileKey(current) === normalizedSourceRoot)
+                if (currentKey === normalizedSourceRoot)
                     break;
                 const parent = path.dirname(current);
-                if (parent === current)
-                    break;
                 current = parent;
+                currentKey = normalizeFileKey(current);
             }
         }
         return Array.from(sourceInputFiles);
@@ -139,16 +163,19 @@ export class ModuleStyleGraphRequestCache {
         const files = [path.join(packageRoot, 'package.json')];
         let current = packageRoot;
         const graphRoot = normalizeFileKey(this.options.root);
-        while (true) {
-            files.push(path.join(current, 'tsconfig.json'));
-            if (normalizeFileKey(current) === graphRoot)
+        let reachedGraphRoot = false;
+        while (!reachedGraphRoot) {
+            const tsconfig = path.join(current, 'tsconfig.json');
+            files.push(tsconfig);
+            reachedGraphRoot = normalizeFileKey(current) === graphRoot;
+            if (reachedGraphRoot)
                 break;
             const parent = path.dirname(current);
             if (parent === current)
                 break;
             current = parent;
         }
-        return files;
+        return Array.from(new Set(files));
     }
     getLoadResultKey(parsed) {
         return `${parsed.packageName}\0${parsed.stylePath}`;

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

@@ -62,6 +62,7 @@ export class StyleCodeFactory {
     }
     async createDependencyStyleCode(context, cache, specifiers, mapSpecifier = (specifier) => specifier) {
         const results = [];
+        const cacheInputFiles = [];
         const imports = [];
         const watchFiles = [...context.configPaths];
         for (const specifier of specifiers) {
@@ -74,12 +75,14 @@ export class StyleCodeFactory {
             }
             const resolvedSpecifier = toDevDependencyImportSpecifier(context, outputSpecifier);
             imports.push(resolvedSpecifier.specifier);
+            cacheInputFiles.push(...(resolvedSpecifier.cacheInputFiles ?? []));
             if (resolvedSpecifier.watchFile) {
                 watchFiles.push(resolvedSpecifier.watchFile);
             }
         }
         return mergeLoadResults({
             code: createImportCode(imports),
+            cacheInputFiles,
             watchFiles,
         }, ...results);
     }
@@ -144,6 +147,7 @@ export class StyleCodeFactory {
         const moduleStyleResults = [];
         const moduleStyleSpecifiers = [];
         const moduleStyleWatchFiles = [];
+        const moduleStyleCacheInputFiles = [];
         for (const specifier of entry.moduleStyleImports) {
             const result = this.toDevModuleImportSpecifier(specifier, context, cache, sourceStyleDir);
             const parsed = this.parsePackageStyleIdInRequest(result, cache);
@@ -154,6 +158,7 @@ export class StyleCodeFactory {
             }
             const resolvedSpecifier = toDevDependencyImportSpecifier(context, result);
             moduleStyleSpecifiers.push(resolvedSpecifier.specifier);
+            moduleStyleCacheInputFiles.push(...(resolvedSpecifier.cacheInputFiles ?? []));
             if (resolvedSpecifier.watchFile) {
                 moduleStyleWatchFiles.push(resolvedSpecifier.watchFile);
             }
@@ -179,6 +184,7 @@ export class StyleCodeFactory {
                 ...moduleStyleWatchFiles,
                 ...sourceFiles.filter((file) => /\.(ts|tsx)$/.test(file)),
             ],
+            cacheInputFiles: moduleStyleCacheInputFiles,
         });
     }
     toDevModuleImportSpecifier(specifier, context, cache, sourceStyleDir) {

package/package.json

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