auklet 0.3.1 → 0.3.2

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;
@@ -100,5 +102,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?.();
@@ -226,39 +229,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 +285,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/package.json

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