@windwalker-io/core 4.2.1 → 4.2.3

package/dist/next.d.ts

@@ -18,6 +18,13 @@ export declare function containsMiddleGlob(str: string): boolean;
 
 export declare function cssModulize(entry: string, dest: string): CssModulizeProcessor;
 
+export declare function cssModulizeDeep(stage: string, entry: string, dest: string, options?: CssModulizeDeepOptions): CssModulizeProcessor;
+
+export declare interface CssModulizeDeepOptions {
+    mergeCss?: boolean;
+    parseBlades?: boolean;
+}
+
 declare class CssModulizeProcessor implements ProcessorInterface {
     protected processor: ReturnType<typeof css>;
     protected bladePatterns: string[];
@@ -54,7 +61,14 @@ export declare function installVendors(npmVendors?: string[], to?: string): {
 
 export declare function jsModulize(entry: string, dest: string, options?: JsModulizeOptions): JsModulizeProcessor;
 
-declare interface JsModulizeOptions {
+export declare function jsModulizeDeep(stage: string, entry: string, dest: string, options?: JsModulizeDeepOptions): JsModulizeProcessor;
+
+export declare interface JsModulizeDeepOptions extends JsModulizeOptions {
+    mergeScripts?: boolean;
+    parseBlades?: boolean;
+}
+
+export declare interface JsModulizeOptions {
     tmpPath?: string;
     cleanTmp?: boolean;
 }

package/dist/next.js

@@ -1,4 +1,4 @@
-import { getGlobBaseFromPattern, callback, css, js, shortHash, plugin, callbackAfterBuild, copyGlob, symlink } from "@windwalker-io/fusion-next";
+import { getGlobBaseFromPattern, callback, css, js, plugin, callbackAfterBuild, copyGlob, symlink } from "@windwalker-io/fusion-next";
 import isGlob from "is-glob";
 import micromatch from "micromatch";
 import path, { relative, normalize, resolve } from "node:path";
@@ -55,7 +55,7 @@ function findModules(suffix = "", rootModule = "src/Module") {
     }) || [];
   }).flat();
   if (rootModule) {
-    vendors.unshift(rootModule + "/" + suffix);
+    vendors.push(rootModule + "/" + suffix);
   }
   return [...new Set(vendors)];
 }
@@ -199,6 +199,19 @@ function systemCSSFix() {
 function cssModulize(entry, dest) {
   return new CssModulizeProcessor(css(entry, dest));
 }
+function cssModulizeDeep(stage, entry, dest, options = {}) {
+  const processor = cssModulize(entry, dest);
+  if (options.mergeCss ?? true) {
+    processor.mergeCss(findModules(`${stage}/**/assets/*.scss`));
+  }
+  if (options.parseBlades ?? true) {
+    processor.parseBlades(
+      findModules(`${stage}/**/*.blade.php`),
+      findPackages("views/**/*.blade.php")
+    );
+  }
+  return processor;
+}
 class CssModulizeProcessor {
   constructor(processor, bladePatterns = [], cssPatterns = []) {
     this.processor = processor;
@@ -267,6 +280,21 @@ ${imports}
 function jsModulize(entry, dest, options = {}) {
   return new JsModulizeProcessor(js(entry, dest), options);
 }
+function jsModulizeDeep(stage, entry, dest, options = {}) {
+  const processor = jsModulize(entry, dest, options).stage(stage.toLowerCase());
+  if (options.mergeScripts ?? true) {
+    processor.mergeScripts(
+      findModules(`${stage}/**/assets/*.ts`)
+    );
+  }
+  if (options.parseBlades ?? true) {
+    processor.parseBlades(
+      findModules(`${stage}/**/*.blade.php`),
+      findPackages("views/**/*.blade.php")
+    );
+  }
+  return processor;
+}
 class JsModulizeProcessor {
   constructor(processor, options = {}) {
     this.processor = processor;
@@ -285,6 +313,9 @@ class JsModulizeProcessor {
       builder.postBuildCallbacks.push((options, bundle) => {
         fs$1.removeSync(tmpPath);
       });
+      builder.serverStopCallbacks.push((options, bundle) => {
+        fs$1.removeSync(tmpPath);
+      });
     }
     this.ignoreMainImport(task);
     builder.resolveIdCallbacks.push((id) => {
@@ -293,11 +324,12 @@ class JsModulizeProcessor {
       }
     });
     const scriptFiles = findFilesFromGlobArray(this.scriptPatterns);
-    const bladeFiles = parseScriptsFromBlades(this.bladePatterns);
+    const bladeFiles = findBladeFiles(this.bladePatterns);
     builder.loadCallbacks.push((src, options) => {
       const srcFile = stripUrlQuery(src);
+      const scripts = {};
       if (normalize(srcFile) === inputFile) {
-        let listJS = "{\n";
+        const bladeScripts = parseScriptsFromBlades(bladeFiles);
         for (const scriptFile of scriptFiles) {
           let fullpath = scriptFile.fullpath;
           if (fullpath.endsWith(".d.ts")) {
@@ -310,25 +342,31 @@ class JsModulizeProcessor {
             key = this.stagePrefix + "/" + key;
           }
           key = "view:" + crypto.createHash("md5").update(key).digest("hex");
-          listJS += `'${key}': () => import('${fullpath}'),
-`;
+          scripts[key] = fullpath;
         }
         const listens = [];
         fs$1.ensureDirSync(tmpPath);
-        for (const result of bladeFiles) {
+        for (const result of bladeScripts) {
           let key = result.as;
-          const tmpFile = tmpPath + "/" + result.path.replace(/\\|\//g, "_") + "-" + shortHash(result.code) + ".ts";
+          const filename = result.path.replace(/\\|\//g, "_");
+          const tmpFile = tmpPath + "/" + filename + ".ts";
           if (!fs$1.existsSync(tmpFile) || fs$1.readFileSync(tmpFile, "utf8") !== result.code) {
             fs$1.writeFileSync(tmpFile, result.code);
           }
-          listJS += `'inline:${key}': () => import('${tmpFile}'),
-`;
+          scripts[`inline:${key}`] = tmpFile;
           const fullpath = resolve(result.file.fullpath).replace(/\\/g, "/");
           if (!listens.includes(fullpath)) {
             listens.push(fullpath);
           }
         }
-        listJS += "}";
+        let listJS = `{
+`;
+        for (const key in scripts) {
+          const fullpath = scripts[key];
+          listJS += `'${key}': () => import('${fullpath}'),
+`;
+        }
+        listJS += `}`;
         builder.watches.push(...listens);
         let { code, comments } = stripComments(fs$1.readFileSync(srcFile, "utf-8"));
         code = code.replace(/defineJsModules\((.*?)\)/g, listJS);
@@ -371,8 +409,10 @@ class JsModulizeProcessor {
     return this;
   }
 }
-function parseScriptsFromBlades(patterns) {
-  let files = findFilesFromGlobArray(Array.isArray(patterns) ? patterns : [patterns]);
+function findBladeFiles(patterns) {
+  return findFilesFromGlobArray(Array.isArray(patterns) ? patterns : [patterns]);
+}
+function parseScriptsFromBlades(files) {
   return files.map((file) => {
     const bladeText = fs$1.readFileSync(file.fullpath, "utf8");
     const html = parse(bladeText);
@@ -520,6 +560,7 @@ export {
   cloneAssets,
   containsMiddleGlob,
   cssModulize,
+  cssModulizeDeep,
   ensureDirPath,
   findFilesFromGlobArray,
   findModules,
@@ -528,6 +569,7 @@ export {
   injectSystemJS,
   installVendors,
   jsModulize,
+  jsModulizeDeep,
   loadJson,
   removeLastGlob,
   resolveModuleRealpath,

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@windwalker-io/core",
-  "version": "4.2.1",
+  "version": "4.2.3",
   "type": "module",
   "description": "Windwalker Core JS package",
   "scripts": {
     "build": "yarn build:next && yarn build:debugger",
     "dev": "yarn dev:debugger",
-    "build:next": "vite build --config vite.config.next.ts",
+    "build:next": "vite build --config vite.next.config.ts",
     "dev:next": "yarn build:next --watch",
-    "build:debugger": "vite build --config vite.config.debugger.ts",
-    "dev:debugger": "vite --config vite.config.debugger.ts"
+    "build:debugger": "vite build --config vite.debugger.config.ts",
+    "dev:debugger": "vite --config vite.debugger.config.ts"
   },
   "exports": {
     ".": "./src/index.js",

package/src/app/app.ts

@@ -1,8 +1,12 @@
 type Route = string | RouteLoader;
 type RouteLoader = () => Promise<any>;
 
+let currentProps: Record<string, any> | null = null;
+
 export class App {
   routes: Record<string, RouteLoader> = {};
+  queue: (() => Promise<any>)[] = [];
+  queueRunning = false;
 
   constructor(routes: Record<string, Route> = {}) {
     this.registerRoutes(routes);
@@ -42,9 +46,48 @@ export class App {
     return target();
   }
 
+  async importSync<T = any>(route: string, props: Record<string, any> = {}): Promise<T> {
+    return new Promise<any>((resolve) => {
+      const target = this.routes[route];
+
+      if (!target) {
+        throw new Error(`Unable to import file: ${route}, file not found.`);
+      }
+
+      this.queue.push(async () => {
+        currentProps = props;
+        resolve(await target());
+      });
+
+      this.runQueue();
+    });
+  }
+
+  async runQueue() {
+    if (!this.queueRunning) {
+      this.queueRunning = true;
+      let item: () => any;
+
+      while (item = this.queue.shift()) {
+        await item();
+      }
+
+      this.queueRunning = false;
+    }
+  }
+
   reset() {
     this.routes = {};
 
     return this;
   }
 }
+
+export function useMacroProps<T extends Record<string, any> = Record<string, any>>(): T {
+  console.log('get');
+  if (currentProps == null) {
+    throw new Error('Cannot get macro props.');
+  }
+  
+  return { ...currentProps } as T;
+}

package/src/next/fusion/processors/cssModulize.ts

@@ -1,15 +1,37 @@
-import { stripUrlQuery } from '@/next';
 import { type ConfigBuilder, css, type ProcessorInterface, type ProcessorPreview } from '@windwalker-io/fusion-next';
 import { WatchTask } from '@windwalker-io/fusion-next/src/types';
 import fg from 'fast-glob';
 import fs from 'fs-extra';
 import { parse } from 'node-html-parser';
 import { normalize, resolve } from 'node:path';
+import { findModules, findPackages, stripUrlQuery } from '../../utilities';
 
 export function cssModulize(entry: string, dest: string) {
   return new CssModulizeProcessor(css(entry, dest));
 }
 
+export interface CssModulizeDeepOptions {
+  mergeCss?: boolean;
+  parseBlades?: boolean;
+}
+
+export function cssModulizeDeep(stage: string, entry: string, dest: string, options: CssModulizeDeepOptions = {}) {
+  const processor = cssModulize(entry, dest);
+
+  if (options.mergeCss ?? true) {
+    processor.mergeCss(findModules(`${stage}/**/assets/*.scss`));
+  }
+
+  if (options.parseBlades ?? true) {
+    processor.parseBlades(
+      findModules(`${stage}/**/*.blade.php`),
+      findPackages('views/**/*.blade.php'),
+    );
+  }
+
+  return processor;
+}
+
 class CssModulizeProcessor implements ProcessorInterface {
 
   constructor(

package/src/next/fusion/processors/index.ts

@@ -1,4 +1,4 @@
-export { cssModulize } from './cssModulize';
-export { jsModulize } from './jsModulize';
+export { cssModulize, cssModulizeDeep, type CssModulizeDeepOptions } from './cssModulize';
+export { jsModulize, jsModulizeDeep, type JsModulizeOptions, type JsModulizeDeepOptions } from './jsModulize';
 export { installVendors } from './installVendors';
 export { cloneAssets } from './cloneAssets';

package/src/next/fusion/processors/jsModulize.ts

@@ -1,19 +1,18 @@
-import { type FindFileResult, findFilesFromGlobArray, stripUrlQuery } from '@/next';
 import {
   type BuildTask,
   type ConfigBuilder,
+  js,
   type MaybePromise,
+  plugin as addPlugin,
   type ProcessorInterface,
   type ProcessorPreview,
-  js,
   shortHash,
-  plugin as addPlugin,
 } from '@windwalker-io/fusion-next';
-import { WatchTask } from '@windwalker-io/fusion-next/src/types';
 import fs from 'fs-extra';
-import crypto from 'node:crypto';
 import { parse } from 'node-html-parser';
+import crypto from 'node:crypto';
 import { normalize, resolve } from 'node:path';
+import { type FindFileResult, findFilesFromGlobArray, findModules, findPackages, stripUrlQuery } from '../../utilities';
 
 export interface JsModulizeOptions {
   tmpPath?: string;
@@ -24,6 +23,31 @@ export function jsModulize(entry: string, dest: string, options: JsModulizeOptio
   return new JsModulizeProcessor(js(entry, dest), options);
 }
 
+export interface JsModulizeDeepOptions extends JsModulizeOptions {
+  mergeScripts?: boolean;
+  parseBlades?: boolean;
+}
+
+export function jsModulizeDeep(stage: string, entry: string, dest: string, options: JsModulizeDeepOptions = {}) {
+  const processor = jsModulize(entry, dest, options)
+    .stage(stage.toLowerCase());
+
+  if (options.mergeScripts ?? true) {
+    processor.mergeScripts(
+      findModules(`${stage}/**/assets/*.ts`),
+    );
+  }
+
+  if (options.parseBlades ?? true) {
+    processor.parseBlades(
+      findModules(`${stage}/**/*.blade.php`),
+      findPackages('views/**/*.blade.php'),
+    );
+  }
+
+  return processor;
+}
+
 export class JsModulizeProcessor implements ProcessorInterface {
   protected scriptPatterns: string[] = [];
   protected bladePatterns: string[] = [];
@@ -39,36 +63,15 @@ export class JsModulizeProcessor implements ProcessorInterface {
     const tmpPath = this.options.tmpPath ?? resolve('./tmp/fusion/jsmodules/').replace(/\\/g, '/');
     const clean = this.options.cleanTmp ?? true;
 
-    // const appFileName = 'js/' + this.stagePrefix + '/app.js';
-    // const appSrcFileName = 'resources/assets/src/' + this.stagePrefix + '/app.js';
-    // const task = builder.addTask(appFileName);
-
     if (clean) {
       builder.postBuildCallbacks.push((options, bundle) => {
         fs.removeSync(tmpPath);
       });
+      builder.serverStopCallbacks.push((options, bundle) => {
+        fs.removeSync(tmpPath);
+      });
     }
 
-    // builder.merge({
-    //   resolve: {
-    //     alias: {
-    //       '@main': task.input
-    //     }
-    //   }
-    // });
-
-    // builder.entryFileNamesCallbacks.push((chunkInfo) => {
-    //   if (chunkInfo.facadeModuleId === appSrcFileName) {
-    //     return appFileName;
-    //   }
-    // });
-    //
-    // builder.resolveIdCallbacks.push((id) => {
-    //   if (id === task.input) {
-    //     return appSrcFileName;
-    //   }
-    // });
-
     this.ignoreMainImport(task);
 
     builder.resolveIdCallbacks.push((id) => {
@@ -77,24 +80,27 @@ export class JsModulizeProcessor implements ProcessorInterface {
       }
     });
 
+    // Todo: Must dynamic changes in load() hook
     const scriptFiles = findFilesFromGlobArray(this.scriptPatterns);
-    const bladeFiles = parseScriptsFromBlades(this.bladePatterns);
+    const bladeFiles = findBladeFiles(this.bladePatterns);
 
     // Watches
-    // for (const bladeFile of bladeFiles) {
+    // Currently we don't watch blade files because not necessary to reload full-pages.
+    // for (const bladeFile of bladeScripts) {
     //   builder.watches.push({
     //     file: resolve(bladeFile.file.fullpath),
     //     moduleFile: inputFile,
-    //     updateType: 'full-reload',
+    //     updateType: 'js-update',
     //   } satisfies WatchTask);
     // }
 
     builder.loadCallbacks.push((src, options) => {
       const srcFile = stripUrlQuery(src);
-
+      const scripts: Record<string, string> = {};
+      
       // if (src === appSrcFileName) {
       if (normalize(srcFile) === inputFile) {
-        let listJS = "{\n";
+        const bladeScripts = parseScriptsFromBlades(bladeFiles);
 
         // Merge standalone ts files
         for (const scriptFile of scriptFiles) {
@@ -116,7 +122,7 @@ export class JsModulizeProcessor implements ProcessorInterface {
           // md5
           key = 'view:' + crypto.createHash('md5').update(key).digest('hex');
 
-          listJS += `'${key}': () => import('${fullpath}'),\n`;
+          scripts[key] = fullpath;
         }
 
         // Parse from blades
@@ -124,19 +130,16 @@ export class JsModulizeProcessor implements ProcessorInterface {
 
         fs.ensureDirSync(tmpPath);
 
-        for (const result of bladeFiles) {
+        for (const result of bladeScripts) {
           let key = result.as;
-          const tmpFile = tmpPath + '/' + result.path.replace(/\\|\//g, '_') + '-' + shortHash(result.code) + '.ts';
+          const filename = result.path.replace(/\\|\//g, '_');
+          const tmpFile = tmpPath + '/' + filename + '.ts';
 
           if (!fs.existsSync(tmpFile) || fs.readFileSync(tmpFile, 'utf8') !== result.code) {
             fs.writeFileSync(tmpFile, result.code);
           }
 
-          // if (this.stagePrefix) {
-          //   key = this.stagePrefix + '/' + key;
-          // }
-
-          listJS += `'inline:${key}': () => import('${tmpFile}'),\n`;
+          scripts[`inline:${key}`] = tmpFile;
 
           const fullpath = resolve(result.file.fullpath).replace(/\\/g, '/');
 
@@ -145,19 +148,14 @@ export class JsModulizeProcessor implements ProcessorInterface {
           }
         }
 
-        listJS += "}";
+        let listJS = `{\n`;
 
-//         const loaderPath = resolve('./vendor/windwalker/core/assets/core/src/next/app.ts')
-//           .replace(/\\/g, '/');
-//
-//         const ts = `
-// import { App } from '${loaderPath}';
-//
-// const app = new App();
-// app.registerRoutes(${listJS});
-//
-// export default app;
-//   `;
+        for (const key in scripts) {
+          const fullpath = scripts[key];
+          listJS += `'${key}': () => import('${fullpath}'),\n`;
+        }
+
+        listJS += `}`;
 
         // Listen extra files
         builder.watches.push(...listens);
@@ -237,9 +235,11 @@ interface ScriptResult {
 //     .filter((c) => c.trim() !== '');
 // }
 
-function parseScriptsFromBlades(patterns: string | string[]): ScriptResult[] {
-  let files = findFilesFromGlobArray(Array.isArray(patterns) ? patterns : [patterns]);
+function findBladeFiles(patterns: string | string[]) {
+  return findFilesFromGlobArray(Array.isArray(patterns) ? patterns : [patterns]);
+}
 
+function parseScriptsFromBlades(files: FindFileResult[]): ScriptResult[] {
   return files.map((file) => {
     const bladeText = fs.readFileSync(file.fullpath, 'utf8');
 

package/src/next/utilities/asset-sync.ts

@@ -19,7 +19,7 @@ export function findModules(suffix = '', rootModule: string | null = 'src/Module
     .flat();
 
   if (rootModule) {
-    vendors.unshift(rootModule + '/' + suffix);
+    vendors.push(rootModule + '/' + suffix);
   }
 
   return [...new Set(vendors)];