@plumeria/webpack-plugin 0.15.3 → 0.15.5

package/dist/index.d.ts

@@ -1,12 +1,19 @@
 import type { Compiler } from 'webpack';
 import { CSSObject } from './types';
+interface PlumeriaPluginOptions {
+    entryPaths: string;
+}
 export declare class PlumeriaPlugin {
-    private outputFileName;
     private stylesByFile;
+    private currentPageFiles;
     private outFile;
-    constructor(outputFileName?: string);
+    private options;
+    constructor(options: PlumeriaPluginOptions);
     apply(compiler: Compiler): void;
+    private updateCurrentPageFiles;
     registerFileStyles(filePath: string, styles: CSSObject): void;
+    private isCurrentPageFile;
     private generateOrderedCSS;
     private writeCSS;
 }
+export {};

package/dist/index.js

@@ -8,20 +8,25 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const PLUGIN_NAME = 'PlumeriaPlugin';
 class PlumeriaPlugin {
-    outputFileName;
     stylesByFile = new Map();
+    currentPageFiles = new Set();
     outFile;
-    constructor(outputFileName = 'zero-virtual.css') {
-        this.outputFileName = outputFileName;
+    options;
+    constructor(options) {
+        this.options = options;
     }
     apply(compiler) {
-        this.outFile = path_1.default.resolve(__dirname, '..', this.outputFileName);
+        this.outFile = path_1.default.resolve(__dirname, '..', 'zero-virtual.css');
         compiler.hooks.invalid.tap(PLUGIN_NAME, (filename) => {
             if (filename) {
                 const absPath = path_1.default.resolve(filename);
                 this.stylesByFile.delete(absPath);
+                this.currentPageFiles.delete(absPath);
             }
         });
+        compiler.hooks.watchRun.tap(PLUGIN_NAME, (compiler) => {
+            this.updateCurrentPageFiles(compiler);
+        });
         compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (nmf) => {
             nmf.hooks.createModule.tap(PLUGIN_NAME, (createData) => {
                 const modPath = createData.matchResource ?? createData.resourceResolveData?.path;
@@ -32,43 +37,74 @@ class PlumeriaPlugin {
             });
         });
     }
+    updateCurrentPageFiles(compiler) {
+        const entries = compiler.options.entry;
+        if (entries && typeof entries === 'object') {
+            this.currentPageFiles.clear();
+            Object.keys(entries).forEach((entryName) => {
+                if (entryName.startsWith(this.options.entryPaths)) {
+                    const entry = entries[entryName];
+                    if (Array.isArray(entry)) {
+                        entry.forEach((file) => {
+                            this.currentPageFiles.add(path_1.default.resolve(file));
+                        });
+                    }
+                    else if (typeof entry === 'string') {
+                        this.currentPageFiles.add(path_1.default.resolve(entry));
+                    }
+                }
+            });
+        }
+    }
     registerFileStyles(filePath, styles) {
         const absPath = path_1.default.resolve(filePath);
         const prev = this.stylesByFile.get(absPath) || {
             filePath,
-            globalStyles: '',
             keyframeStyles: '',
             varStyles: '',
             themeStyles: '',
+            globalStyles: '',
             baseStyles: '',
         };
-        this.stylesByFile.set(absPath, { ...prev, ...styles });
+        const isCurrentPage = this.isCurrentPageFile(absPath);
+        const updatedStyles = {
+            ...prev,
+            ...styles,
+            isCurrentPage,
+            lastAccessed: Date.now(),
+        };
+        this.stylesByFile.set(absPath, updatedStyles);
         this.writeCSS();
     }
+    isCurrentPageFile(filePath) {
+        return (this.currentPageFiles.has(filePath) ||
+            Array.from(this.currentPageFiles).some((pageFile) => filePath.includes(path_1.default.dirname(pageFile))));
+    }
     generateOrderedCSS() {
         const allStyles = Array.from(this.stylesByFile.values());
-        const globalStylesSet = new Set();
+        const sortedStyles = allStyles.sort((a, b) => (b.lastAccessed || 0) - (a.lastAccessed || 0));
         const keyframeStylesSet = new Set();
         const varStylesSet = new Set();
         const themeStylesSet = new Set();
+        const globalStylesSet = new Set();
         const baseStylesSet = new Set();
-        for (const s of allStyles) {
-            if (s.globalStyles.trim().length > 0)
-                globalStylesSet.add(s.globalStyles);
-            if (s.keyframeStyles.trim().length > 0)
+        for (const s of sortedStyles) {
+            if (s.keyframeStyles?.trim().length > 0)
                 keyframeStylesSet.add(s.keyframeStyles);
-            if (s.varStyles.trim().length > 0)
+            if (s.varStyles?.trim().length > 0)
                 varStylesSet.add(s.varStyles);
-            if (s.themeStyles.trim().length > 0)
+            if (s.themeStyles?.trim().length > 0)
                 themeStylesSet.add(s.themeStyles);
-            if (s.baseStyles.trim().length > 0)
+            if (s.globalStyles?.trim().length > 0)
+                globalStylesSet.add(s.globalStyles);
+            if (s.baseStyles?.trim().length > 0)
                 baseStylesSet.add(s.baseStyles);
         }
         return [
-            ...Array.from(globalStylesSet),
             ...Array.from(keyframeStylesSet),
             ...Array.from(varStylesSet),
             ...Array.from(themeStylesSet),
+            ...Array.from(globalStylesSet),
             ...Array.from(baseStylesSet),
         ]
             .filter(Boolean)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/webpack-plugin",
-  "version": "0.15.3",
+  "version": "0.15.5",
   "description": "Plumeria Webpack plugin",
   "repository": {
     "type": "git",