@lark-apaas/fullstack-rspack-preset 1.0.32-alpha.2 → 1.0.32-alpha.21

package/lib/rspack-plugins/static-assets-plugin.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Static Assets Plugin for Rspack
+ *
+ * Supports importing static files from shared/static directory:
+ * - JSON files → bundled into HTML, injected as window.__STATIC_JSON__
+ * - Other files → converted to URL {clientBasePath}/static/path
+ *
+ * Usage:
+ *   import config from '@shared/static/config.json';
+ *   import logoUrl from '@shared/static/images/logo.png';
+ */
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { Compiler } from '@rspack/core';
+export interface StaticAssetsPluginOptions {
+    /**
+     * Client base path prefix for routes
+     * @default ''
+     */
+    clientBasePath?: string;
+    /**
+     * Root directory for the project
+     * @default process.cwd()
+     */
+    rootDir?: string;
+}
+export declare class StaticAssetsPlugin {
+    private options;
+    private staticDir;
+    private jsonDataCache;
+    private virtualModules;
+    constructor(options?: StaticAssetsPluginOptions);
+    /**
+     * Get the key for a static file path (used for __STATIC_JSON__)
+     */
+    private getJsonKey;
+    /**
+     * Scan and read all JSON files from shared/static directory
+     */
+    private scanJsonFiles;
+    /**
+     * Get JSON data (with caching)
+     */
+    private getJsonData;
+    /**
+     * Generate virtual module content for a static file import
+     */
+    private generateVirtualModuleContent;
+    /**
+     * Get the script content for __STATIC_JSON__ injection
+     */
+    private getStaticJsonScriptContent;
+    /**
+     * Create a dev server middleware that serves static files from shared/static.
+     * This aligns with the Vite preset's configureServer middleware.
+     */
+    createDevMiddleware(): (req: IncomingMessage, res: ServerResponse, next: () => void) => void;
+    apply(compiler: Compiler): void;
+}
+export default StaticAssetsPlugin;

package/lib/rspack-plugins/static-assets-plugin.js

@@ -0,0 +1,383 @@
+"use strict";
+/**
+ * Static Assets Plugin for Rspack
+ *
+ * Supports importing static files from shared/static directory:
+ * - JSON files → bundled into HTML, injected as window.__STATIC_JSON__
+ * - Other files → converted to URL {clientBasePath}/static/path
+ *
+ * Usage:
+ *   import config from '@shared/static/config.json';
+ *   import logoUrl from '@shared/static/images/logo.png';
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticAssetsPlugin = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const glob_1 = require("glob");
+const MIME_TYPES = {
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.otf': 'font/otf',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.txt': 'text/plain',
+    '.html': 'text/html',
+    '.xml': 'application/xml',
+    '.pdf': 'application/pdf',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+};
+const SHARED_STATIC_PREFIX = '@shared/static/';
+const PLUGIN_NAME = 'StaticAssetsPlugin';
+/** File extensions that should be resolved as normal modules instead of static asset URLs */
+const SCRIPT_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.mjs', '.cjs'];
+/**
+ * Split a relative path into the clean path and optional query string.
+ * e.g. "file.md?raw" → ["file.md", "?raw"]
+ */
+function splitQuery(relativePath) {
+    const qIndex = relativePath.indexOf('?');
+    if (qIndex === -1)
+        return [relativePath, ''];
+    return [relativePath.slice(0, qIndex), relativePath.slice(qIndex)];
+}
+/**
+ * Try to resolve a relative path to a real script file on disk.
+ * Handles both explicit extensions (utils.ts) and extensionless imports (utils).
+ * Returns the absolute path if found, null otherwise.
+ */
+function resolveScriptFile(staticDir, cleanPath) {
+    const ext = path.extname(cleanPath).toLowerCase();
+    // Has explicit script extension → resolve directly
+    if (ext && SCRIPT_EXTENSIONS.includes(ext)) {
+        return path.join(staticDir, cleanPath);
+    }
+    // No extension → probe for matching script file on disk
+    if (!ext) {
+        for (const scriptExt of SCRIPT_EXTENSIONS) {
+            const fullPath = path.join(staticDir, cleanPath + scriptExt);
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+    }
+    return null;
+}
+class StaticAssetsPlugin {
+    constructor(options = {}) {
+        this.jsonDataCache = null;
+        this.virtualModules = new Map();
+        this.options = {
+            clientBasePath: '',
+            rootDir: process.cwd(),
+            ...options,
+        };
+        this.staticDir = path.resolve(this.options.rootDir, 'shared/static');
+    }
+    /**
+     * Get the key for a static file path (used for __STATIC_JSON__)
+     */
+    getJsonKey(filePath) {
+        return filePath.replace(/\.json$/, '');
+    }
+    /**
+     * Scan and read all JSON files from shared/static directory
+     */
+    scanJsonFiles() {
+        const jsonData = {};
+        if (!fs.existsSync(this.staticDir)) {
+            return jsonData;
+        }
+        const jsonFiles = glob_1.glob.sync('**/*.json', {
+            cwd: this.staticDir,
+            nodir: true,
+        });
+        for (const file of jsonFiles) {
+            const fullPath = path.join(this.staticDir, file);
+            try {
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                const key = this.getJsonKey(file);
+                jsonData[key] = JSON.parse(content);
+            }
+            catch (e) {
+                console.warn(`[static-assets] Failed to parse JSON file: ${file}`, e);
+            }
+        }
+        return jsonData;
+    }
+    /**
+     * Get JSON data (with caching)
+     */
+    getJsonData() {
+        if (this.jsonDataCache) {
+            return this.jsonDataCache;
+        }
+        this.jsonDataCache = this.scanJsonFiles();
+        return this.jsonDataCache;
+    }
+    /**
+     * Generate virtual module content for a static file import
+     */
+    generateVirtualModuleContent(relativePath) {
+        const isJson = relativePath.endsWith('.json');
+        if (isJson) {
+            const key = this.getJsonKey(relativePath);
+            return `export default window.__STATIC_JSON__['${key}'];`;
+        }
+        else {
+            const envBaseUrl = typeof process !== 'undefined' ? process.env?.STATIC_ASSETS_BASE_URL : undefined;
+            // envBaseUrl (downloadURLPrefix) 已指向 static 目录，无需再拼 /static/
+            const staticUrl = envBaseUrl
+                ? `${envBaseUrl.replace(/\/+$/, '')}/${relativePath}`
+                : `${this.options.clientBasePath}/static/${relativePath}`;
+            return `export default ${JSON.stringify(staticUrl)};`;
+        }
+    }
+    /**
+     * Get the script content for __STATIC_JSON__ injection
+     */
+    getStaticJsonScriptContent() {
+        const jsonData = this.getJsonData();
+        if (Object.keys(jsonData).length === 0) {
+            return '';
+        }
+        return `window.__STATIC_JSON__ = ${JSON.stringify(jsonData)};`;
+    }
+    /**
+     * Create a dev server middleware that serves static files from shared/static.
+     * This aligns with the Vite preset's configureServer middleware.
+     */
+    createDevMiddleware() {
+        const staticDir = this.staticDir;
+        const clientBasePath = this.options.clientBasePath || '';
+        return (req, res, next) => {
+            const staticPrefix = `${clientBasePath}/static/`;
+            const url = req.url || '';
+            if (!url.startsWith(staticPrefix)) {
+                return next();
+            }
+            const rawRelativePath = url.slice(staticPrefix.length).split('?')[0];
+            let relativePath;
+            try {
+                relativePath = decodeURIComponent(rawRelativePath);
+            }
+            catch {
+                res.statusCode = 400;
+                res.end('Bad Request');
+                return;
+            }
+            const filePath = path.join(staticDir, relativePath);
+            // Security: prevent path traversal
+            const normalizedPath = path.normalize(filePath);
+            if (!normalizedPath.startsWith(staticDir)) {
+                res.statusCode = 403;
+                res.end('Forbidden');
+                return;
+            }
+            if (!fs.existsSync(filePath)) {
+                res.statusCode = 404;
+                res.end('Not Found');
+                return;
+            }
+            const stat = fs.statSync(filePath);
+            if (stat.isDirectory()) {
+                res.statusCode = 403;
+                res.end('Forbidden');
+                return;
+            }
+            const ext = path.extname(filePath).toLowerCase();
+            const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+            res.setHeader('Content-Type', contentType);
+            res.setHeader('Cache-Control', 'no-cache');
+            const stream = fs.createReadStream(filePath);
+            stream.pipe(res);
+        };
+    }
+    apply(compiler) {
+        // Create a temporary directory for virtual modules
+        const virtualModulesDir = path.join(this.options.rootDir, 'node_modules', '.cache', 'static-assets-virtual');
+        // Ensure virtual modules directory exists
+        if (!fs.existsSync(virtualModulesDir)) {
+            fs.mkdirSync(virtualModulesDir, { recursive: true });
+        }
+        // Cache for written virtual module contents to avoid repeated disk writes
+        const writtenModules = new Map();
+        // Hook into module resolution to intercept @shared/static/* imports
+        compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (factory) => {
+            factory.hooks.beforeResolve.tap(PLUGIN_NAME, (resolveData) => {
+                const request = resolveData.request;
+                if (!request.startsWith(SHARED_STATIC_PREFIX)) {
+                    return;
+                }
+                const relativePath = request.slice(SHARED_STATIC_PREFIX.length);
+                const [cleanPath, query] = splitQuery(relativePath);
+                // Imports with query params (e.g. ?raw) should resolve to real
+                // paths and let Rspack's native handling process them
+                if (query) {
+                    resolveData.request = path.join(this.staticDir, cleanPath) + query;
+                    return;
+                }
+                // JS/TS files should be resolved to their real paths and bundled normally
+                const scriptPath = resolveScriptFile(this.staticDir, cleanPath);
+                if (scriptPath) {
+                    resolveData.request = scriptPath;
+                    return;
+                }
+                // Generate virtual module content
+                const content = this.generateVirtualModuleContent(cleanPath);
+                // Create a virtual module file
+                const virtualModulePath = path.join(virtualModulesDir, cleanPath.replace(/[/\\]/g, '_') + '.js');
+                // Only write to disk if content has changed
+                const existingContent = writtenModules.get(virtualModulePath);
+                if (existingContent !== content) {
+                    const dir = path.dirname(virtualModulePath);
+                    if (!fs.existsSync(dir)) {
+                        fs.mkdirSync(dir, { recursive: true });
+                    }
+                    fs.writeFileSync(virtualModulePath, content);
+                    writtenModules.set(virtualModulePath, content);
+                }
+                // Redirect the request to the virtual module
+                resolveData.request = virtualModulePath;
+            });
+        });
+        // Inject __STATIC_JSON__ script into HTML
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+            try {
+                // Get HtmlRspackPlugin from compiler
+                let HtmlPlugin;
+                try {
+                    const rspack = compiler.webpack ||
+                        compiler.rspack ||
+                        compiler.constructor.webpack;
+                    if (rspack && rspack.HtmlRspackPlugin) {
+                        HtmlPlugin = rspack.HtmlRspackPlugin;
+                    }
+                    else {
+                        try {
+                            HtmlPlugin = require('html-webpack-plugin');
+                        }
+                        catch {
+                            console.warn(`${PLUGIN_NAME}: HtmlRspackPlugin not found`);
+                            return;
+                        }
+                    }
+                }
+                catch {
+                    console.warn(`${PLUGIN_NAME}: Failed to get HtmlRspackPlugin`);
+                    return;
+                }
+                const hooks = HtmlPlugin.getHooks(compilation);
+                // Use alterAssetTagGroups hook to inject the script tag
+                hooks.alterAssetTagGroups.tap(PLUGIN_NAME, (data) => {
+                    const scriptContent = this.getStaticJsonScriptContent();
+                    if (!scriptContent) {
+                        return data;
+                    }
+                    // Create the script tag
+                    const staticJsonTag = {
+                        tagName: 'script',
+                        voidTag: false,
+                        innerHTML: scriptContent,
+                        attributes: {},
+                    };
+                    // Insert at the beginning of head tags (before other scripts)
+                    data.headTags.unshift(staticJsonTag);
+                    return data;
+                });
+            }
+            catch (error) {
+                console.error(`Error in ${PLUGIN_NAME}:`, error);
+            }
+        });
+        // Watch shared/static directory for changes (dev mode)
+        compiler.hooks.watchRun.tapAsync(PLUGIN_NAME, (_compiler, callback) => {
+            // Invalidate caches on watch run to pick up file changes
+            this.jsonDataCache = null;
+            writtenModules.clear();
+            callback();
+        });
+        // Add shared/static directory to watch dependencies
+        compiler.hooks.afterCompile.tap(PLUGIN_NAME, (compilation) => {
+            if (fs.existsSync(this.staticDir)) {
+                // Add the static directory to watch list
+                compilation.contextDependencies.add(this.staticDir);
+                // Also add individual JSON files
+                const jsonFiles = glob_1.glob.sync('**/*.json', {
+                    cwd: this.staticDir,
+                    nodir: true,
+                });
+                for (const file of jsonFiles) {
+                    const fullPath = path.join(this.staticDir, file);
+                    compilation.fileDependencies.add(fullPath);
+                }
+            }
+        });
+        // Copy shared/static to dist/shared/static for production serving
+        compiler.hooks.afterEmit.tap(PLUGIN_NAME, () => {
+            if (compiler.options.mode === 'development') {
+                return;
+            }
+            if (!fs.existsSync(this.staticDir)) {
+                return;
+            }
+            const outPath = compiler.options.output?.path;
+            if (!outPath) {
+                return;
+            }
+            // outPath is typically dist/client, target is dist/shared/static
+            const distRoot = path.resolve(outPath, '..');
+            const destDir = path.join(distRoot, 'shared', 'static');
+            fs.cpSync(this.staticDir, destDir, { recursive: true });
+            console.log(`[static-assets] Copied shared/static → ${path.relative(this.options.rootDir, destDir)}`);
+        });
+    }
+}
+exports.StaticAssetsPlugin = StaticAssetsPlugin;
+exports.default = StaticAssetsPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-rspack-preset",
-  "version": "1.0.32-alpha.2",
+  "version": "1.0.32-alpha.21",
   "files": [
     "lib",
     "patches",
@@ -31,17 +31,20 @@
     "@babel/parser": "^7.28.0",
     "@babel/traverse": "^7.28.0",
     "@babel/types": "^7.28.2",
-    "@lark-apaas/devtool-kits": "^1.2.15",
-    "@lark-apaas/miaoda-inspector-babel-plugin": "^1.0.0",
-    "@lark-apaas/miaoda-inspector-jsx-runtime": "^1.0.0",
+    "@lark-apaas/devtool-kits": "1.2.17-alpha.34",
+    "@lark-apaas/miaoda-inspector-babel-plugin": "^1.0.2",
     "@lark-apaas/styled-jsx": "^1.0.1",
     "@rspack/plugin-react-refresh": "^1.5.1",
     "@swc/plugin-styled-jsx": "^11.0.0",
     "babel-loader": "^10.0.0",
     "clsx": "^2.1.1",
     "colorjs.io": "^0.5.2",
+    "core-js": "^3.40.0",
     "dotenv": "^16.4.5",
     "echarts": "^6.0.0",
+    "echarts-for-react": "^3.0.2",
+    "glob": "^11.0.0",
+    "lightningcss": "^1.28.0",
     "patch-package": "^8.0.0",
     "postcss-import": "^16.1.1",
     "react-refresh": "^0.17.0",
@@ -52,11 +55,11 @@
     "@rspack/core": "^1.5.5",
     "@types/node": "^22.15.30",
     "typescript": "^5.9.2",
-    "vitest": "^2.1.8"
+    "vitest": "^3.2.4"
   },
   "peerDependencies": {
     "@rspack/core": "^1.5.5",
     "react": ">=16.14.0",
     "react-dom": ">=16.14.0"
   }
-}
+}