@playcraft/build 0.0.14 → 0.0.15

package/dist/utils/obfuscate.d.ts

@@ -0,0 +1,42 @@
+export type ObfuscateLevel = 'light' | 'medium' | 'heavy';
+export declare function getFflateInflateRuntime(): string;
+/**
+ * 对 JS 代码进行混淆 + fflate 压缩，生成自解压 bootstrap
+ */
+export declare function obfuscateAndCompress(jsCode: string, level?: ObfuscateLevel): Promise<{
+    /** fflate inflate 运行时脚本（<script>标签） */
+    runtime: string;
+    /** 自解压 bootstrap 脚本（<script>标签） */
+    bootstrap: string;
+    /** 原始代码大小 */
+    originalSize: number;
+    /** 混淆后大小 */
+    obfuscatedSize: number;
+    /** 压缩后大小（binary） */
+    compressedSize: number;
+    /** 最终大小（base64 + bootstrap） */
+    finalSize: number;
+}>;
+/**
+ * 使用 fflate 压缩引擎代码（替换 LZ4）
+ * 不做混淆，只做压缩
+ */
+export declare function compressWithFflate(code: string): {
+    runtime: string;
+    compressed: string;
+    originalSize: number;
+    compressedSize: number;
+};
+/**
+ * 使用 fflate 压缩 config.json（替换 LZ4）
+ */
+export declare function compressConfigJsonWithFflate(jsonString: string): {
+    dataUrl: string;
+    originalSize: number;
+    compressedSize: number;
+};
+/**
+ * 构建 config.json 解压 patch（fflate 版本）
+ * 拦截 pc.Http.prototype.get，检测 fflate 压缩的 JSON 并解压
+ */
+export declare function buildFflateConfigDecompressPatch(): string;

package/dist/utils/obfuscate.js

@@ -0,0 +1,216 @@
+/**
+ * 代码混淆 + fflate 压缩工具
+ *
+ * 流程：
+ * 1. javascript-obfuscator 混淆（字符串加密、控制流扁平化等）
+ * 2. fflate deflate 压缩
+ * 3. base64 编码
+ * 4. 包装为自解压 bootstrap 脚本
+ */
+import JavaScriptObfuscator from 'javascript-obfuscator';
+import { deflateSync } from 'fflate';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+/**
+ * 混淆级别预设配置
+ */
+const ObfuscatorPresets = {
+    // 轻量级：仅字符串加密 + 标识符混淆，体积膨胀 ~30%
+    light: {
+        compact: true,
+        controlFlowFlattening: false,
+        deadCodeInjection: false,
+        stringArray: true,
+        stringArrayEncoding: ['base64'],
+        stringArrayThreshold: 0.5,
+        stringArrayCallsTransform: true,
+        identifierNamesGenerator: 'hexadecimal',
+        renameGlobals: false,
+        selfDefending: false,
+        splitStrings: false,
+        transformObjectKeys: false,
+    },
+    // 中等：字符串加密 + 控制流扁平化，体积膨胀 ~60%
+    medium: {
+        compact: true,
+        controlFlowFlattening: true,
+        controlFlowFlatteningThreshold: 0.5,
+        deadCodeInjection: false,
+        stringArray: true,
+        stringArrayEncoding: ['base64'],
+        stringArrayThreshold: 0.75,
+        stringArrayCallsTransform: true,
+        identifierNamesGenerator: 'hexadecimal',
+        renameGlobals: false,
+        selfDefending: false,
+        splitStrings: true,
+        splitStringsChunkLength: 10,
+        transformObjectKeys: true,
+    },
+    // 重度：全部开启，体积膨胀 ~100%+
+    heavy: {
+        compact: true,
+        controlFlowFlattening: true,
+        controlFlowFlatteningThreshold: 0.75,
+        deadCodeInjection: true,
+        deadCodeInjectionThreshold: 0.3,
+        stringArray: true,
+        stringArrayEncoding: ['rc4'],
+        stringArrayThreshold: 1,
+        stringArrayCallsTransform: true,
+        identifierNamesGenerator: 'hexadecimal',
+        renameGlobals: false,
+        selfDefending: false,
+        splitStrings: true,
+        splitStringsChunkLength: 5,
+        transformObjectKeys: true,
+        unicodeEscapeSequence: true,
+    },
+};
+/**
+ * fflate inflate 运行时代码（浏览器端）
+ * 从 fflate 库的 UMD 构建中动态加载，确保与 Node 端使用的 fflate 版本一致
+ * 运行后在 window 上暴露 __fflate_inflate 函数
+ */
+let _fflateRuntimeCache = null;
+export function getFflateInflateRuntime() {
+    if (_fflateRuntimeCache)
+        return _fflateRuntimeCache;
+    // 找到 fflate 包的 UMD 构建文件
+    // 从当前文件位置向上查找 node_modules/fflate/umd/index.js
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    // 向上查找 node_modules 目录（支持 pnpm 的嵌套 node_modules 结构）
+    let searchDir = currentDir;
+    let fflateUmdPath = '';
+    for (let i = 0; i < 10; i++) {
+        const candidate = path.join(searchDir, 'node_modules', 'fflate', 'umd', 'index.js');
+        if (fs.existsSync(candidate)) {
+            fflateUmdPath = candidate;
+            break;
+        }
+        const parent = path.dirname(searchDir);
+        if (parent === searchDir)
+            break;
+        searchDir = parent;
+    }
+    if (!fflateUmdPath) {
+        throw new Error('[fflate] 无法找到 fflate UMD 构建文件，请确保 fflate 已安装');
+    }
+    const fflateUmd = fs.readFileSync(fflateUmdPath, 'utf-8');
+    // 包装 UMD 使其在浏览器环境中执行，并将 inflateSync 暴露为 window.__fflate_inflate
+    // UMD 的外层包装会检测环境：typeof self !== 'undefined' ? self : this
+    // 通过 var self=window 确保 fflate 挂载到 window.fflate
+    _fflateRuntimeCache = `!function(){var self=window;${fflateUmd};window.__fflate_inflate=window.fflate.inflateSync}();`;
+    return _fflateRuntimeCache;
+}
+/**
+ * 对 JS 代码进行混淆 + fflate 压缩，生成自解压 bootstrap
+ */
+export async function obfuscateAndCompress(jsCode, level = 'medium') {
+    const originalSize = Buffer.from(jsCode).length;
+    console.log(`[Obfuscator] 开始混淆... 级别: ${level}, 原始大小: ${formatBytes(originalSize)}`);
+    console.log(`[Obfuscator] 混淆中（这可能需要较长时间）...`);
+    const startTime = Date.now();
+    // ① javascript-obfuscator 混淆
+    const obfuscated = JavaScriptObfuscator.obfuscate(jsCode, {
+        ...ObfuscatorPresets[level],
+        target: 'browser',
+        seed: Date.now(),
+        // 不使用 sourceMap
+        sourceMap: false,
+        // 禁用 console 输出
+        disableConsoleOutput: false,
+        // 不使用 domain lock
+        domainLock: [],
+        domainLockRedirectUrl: 'about:blank',
+        // 排除一些 PlayCanvas 关键标识符不被混淆
+        reservedNames: [
+            'pc', 'PlayCanvasESMBundle', 'PRELOAD_MODULES',
+            '__fflate_inflate',
+        ],
+        reservedStrings: [],
+    }).getObfuscatedCode();
+    const obfuscatedSize = Buffer.from(obfuscated).length;
+    const obfuscateTime = ((Date.now() - startTime) / 1000).toFixed(1);
+    console.log(`[Obfuscator] 混淆完成 (${obfuscateTime}s), 大小: ${formatBytes(obfuscatedSize)} (膨胀 ${((obfuscatedSize / originalSize - 1) * 100).toFixed(0)}%)`);
+    // ② fflate deflate 压缩
+    const textEncoder = new TextEncoder();
+    const codeBytes = textEncoder.encode(obfuscated);
+    const compressed = deflateSync(codeBytes, { level: 9 });
+    const compressedSize = compressed.length;
+    console.log(`[Obfuscator] fflate 压缩完成, 大小: ${formatBytes(compressedSize)} (压缩率 ${((1 - compressedSize / obfuscatedSize) * 100).toFixed(0)}%)`);
+    // ③ 转 base64
+    const base64 = Buffer.from(compressed).toString('base64');
+    // ④ 生成 bootstrap 自解压脚本
+    // 运行时：base64 解码 → fflate inflate 解压 → 创建 <script> 执行
+    const bootstrapCode = `!function(){var b=atob("${base64}"),a=new Uint8Array(b.length);for(var i=0;i<b.length;i++)a[i]=b.charCodeAt(i);var d=__fflate_inflate(a),s="";for(var i=0;i<d.length;i+=8192)s+=String.fromCharCode.apply(null,d.subarray(i,i+8192));var e=document.createElement("script");e.textContent=decodeURIComponent(escape(s));document.currentScript.parentNode.insertBefore(e,document.currentScript)}();`;
+    const runtime = `<script>${getFflateInflateRuntime()}</script>`;
+    const bootstrap = `<script>${bootstrapCode}</script>`;
+    const finalSize = runtime.length + bootstrap.length;
+    console.log(`[Obfuscator] 最终大小: ${formatBytes(finalSize)} (原始 ${formatBytes(originalSize)} → 节省 ${((1 - finalSize / originalSize) * 100).toFixed(0)}%)`);
+    return {
+        runtime,
+        bootstrap,
+        originalSize,
+        obfuscatedSize,
+        compressedSize,
+        finalSize,
+    };
+}
+/**
+ * 使用 fflate 压缩引擎代码（替换 LZ4）
+ * 不做混淆，只做压缩
+ */
+export function compressWithFflate(code) {
+    const originalSize = Buffer.from(code).length;
+    // fflate deflate 压缩
+    const textEncoder = new TextEncoder();
+    const codeBytes = textEncoder.encode(code);
+    const compressed = deflateSync(codeBytes, { level: 9 });
+    const compressedSize = compressed.length;
+    // 转 base64
+    const base64 = Buffer.from(compressed).toString('base64');
+    // 生成自解压脚本
+    const wrapper = `!function(){var b=atob("${base64}"),a=new Uint8Array(b.length);for(var i=0;i<b.length;i++)a[i]=b.charCodeAt(i);var d=__fflate_inflate(a),s="";for(var i=0;i<d.length;i+=8192)s+=String.fromCharCode.apply(null,d.subarray(i,i+8192));var e=document.createElement("script");e.textContent=decodeURIComponent(escape(s));document.currentScript.parentNode.insertBefore(e,document.currentScript)}();`;
+    const runtime = `<script>${getFflateInflateRuntime()}</script>`;
+    const compressedScript = `<script>${wrapper}</script>`;
+    console.log(`[fflate] 引擎压缩: ${formatBytes(originalSize)} → ${formatBytes(compressedSize)} (压缩率 ${((1 - compressedSize / originalSize) * 100).toFixed(0)}%)`);
+    return {
+        runtime,
+        compressed: compressedScript,
+        originalSize,
+        compressedSize,
+    };
+}
+/**
+ * 使用 fflate 压缩 config.json（替换 LZ4）
+ */
+export function compressConfigJsonWithFflate(jsonString) {
+    const originalSize = Buffer.from(jsonString).length;
+    const textEncoder = new TextEncoder();
+    const jsonBytes = textEncoder.encode(jsonString);
+    const compressed = deflateSync(jsonBytes, { level: 9 });
+    const compressedSize = compressed.length;
+    const compressedBase64 = Buffer.from(compressed).toString('base64');
+    // 使用 fflate-json 前缀标识格式
+    const dataUrl = `data:application/x-fflate-json;base64,${compressedBase64}`;
+    const ratio = ((1 - compressedSize / originalSize) * 100).toFixed(1);
+    console.log(`[fflate] config.json 压缩: ${formatBytes(originalSize)} → ${formatBytes(compressedSize)} (减少 ${ratio}%)`);
+    return { dataUrl, originalSize, compressedSize };
+}
+/**
+ * 构建 config.json 解压 patch（fflate 版本）
+ * 拦截 pc.Http.prototype.get，检测 fflate 压缩的 JSON 并解压
+ */
+export function buildFflateConfigDecompressPatch() {
+    return `!function(){function p(){if(!window.pc||!pc.Http)return!1;var o=pc.Http.prototype.get;return pc.Http.prototype.get=function(e,t,n){"function"==typeof t&&(n=t,t={});if("string"==typeof e&&e.startsWith("data:application/x-fflate-json;base64,")){try{var r=e.replace("data:application/x-fflate-json;base64,",""),b=atob(r),a=new Uint8Array(b.length);for(var i=0;i<b.length;i++)a[i]=b.charCodeAt(i);var d=__fflate_inflate(a),s="";for(var i=0;i<d.length;i+=8192)s+=String.fromCharCode.apply(null,d.subarray(i,i+8192));s=decodeURIComponent(escape(s));var j=JSON.parse(s);n(null,j)}catch(x){console.error("[fflate Config] Decompression error:",x);n(x)}return}o.call(this,e,t,n)},!0}if(!p()){var c=0,i=setInterval(function(){(p()||++c>100)&&clearInterval(i)},10)}}();`;
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}

package/dist/vite/plugin-obfuscate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Vite 插件：代码混淆 + fflate 压缩
+ *
+ * 在所有其他插件处理完成后，对最终 HTML 中的 IIFE 脚本进行：
+ * 1. javascript-obfuscator 混淆
+ * 2. fflate deflate 压缩
+ * 3. base64 编码 + 自解压 bootstrap 包装
+ */
+import type { Plugin } from 'vite';
+import { type ObfuscateLevel } from '../utils/obfuscate.js';
+export interface ObfuscatePluginOptions {
+    enabled: boolean;
+    level: ObfuscateLevel;
+    /** 是否已经注入了 fflate 运行时（如 compressEngine 已启用） */
+    fflateRuntimeInjected: boolean;
+}
+/**
+ * 代码混淆插件
+ *
+ * 在 generateBundle 阶段对 HTML 中的 IIFE 脚本块进行混淆+压缩
+ */
+export declare function viteObfuscatePlugin(options: ObfuscatePluginOptions): Plugin;

package/dist/vite/plugin-obfuscate.js

@@ -0,0 +1,52 @@
+import { obfuscateAndCompress } from '../utils/obfuscate.js';
+/**
+ * 代码混淆插件
+ *
+ * 在 generateBundle 阶段对 HTML 中的 IIFE 脚本块进行混淆+压缩
+ */
+export function viteObfuscatePlugin(options) {
+    return {
+        name: 'vite-plugin-obfuscate',
+        enforce: 'post',
+        async generateBundle(_outputOptions, bundle) {
+            if (!options.enabled)
+                return;
+            // 找到 HTML 文件
+            for (const [fileName, chunk] of Object.entries(bundle)) {
+                if (!fileName.endsWith('.html') || chunk.type !== 'asset')
+                    continue;
+                const html = typeof chunk.source === 'string' ? chunk.source : new TextDecoder().decode(chunk.source);
+                // 查找 IIFE 脚本块（包含 "Bundled ESM Scripts (IIFE)" 注释的 <script> 标签）
+                const iifePattern = /<script>\s*\/\*\s*Bundled ESM Scripts \(IIFE\)\s*\*\/\s*([\s\S]*?)\s*<\/script>/;
+                const match = html.match(iifePattern);
+                if (!match) {
+                    console.log('[Obfuscate] 未找到 IIFE 脚本块，跳过混淆');
+                    continue;
+                }
+                const iifeCode = match[1];
+                console.log(`[Obfuscate] 找到 IIFE 脚本块 (${(iifeCode.length / 1024).toFixed(0)} KB)，开始混淆...`);
+                try {
+                    const result = await obfuscateAndCompress(iifeCode, options.level);
+                    // 构建替换内容
+                    // 如果 fflate 运行时已经通过 compressEngine 注入，则不重复注入
+                    const runtimeScript = options.fflateRuntimeInjected
+                        ? ''
+                        : result.runtime;
+                    // 替换原始 IIFE 块为：fflate runtime（如需） + 自解压 bootstrap
+                    const replacement = `${runtimeScript}${result.bootstrap}`;
+                    const newHtml = html.replace(match[0], replacement);
+                    // 更新 bundle
+                    chunk.source = newHtml;
+                    console.log(`[Obfuscate] 混淆完成！`);
+                    console.log(`  原始: ${(result.originalSize / 1024).toFixed(0)} KB`);
+                    console.log(`  混淆后: ${(result.obfuscatedSize / 1024).toFixed(0)} KB (+${((result.obfuscatedSize / result.originalSize - 1) * 100).toFixed(0)}%)`);
+                    console.log(`  压缩后: ${(result.compressedSize / 1024).toFixed(0)} KB (压缩率 ${((1 - result.compressedSize / result.obfuscatedSize) * 100).toFixed(0)}%)`);
+                    console.log(`  最终: ${(result.finalSize / 1024).toFixed(0)} KB (vs 原始 ${((result.finalSize / result.originalSize * 100)).toFixed(0)}%)`);
+                }
+                catch (error) {
+                    console.error('[Obfuscate] 混淆失败，保留原始代码:', error);
+                }
+            }
+        },
+    };
+}

package/dist/vite/plugin-template-minifier.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Vite 插件：模板字符串压缩
+ *
+ * 在构建完成后（closeBundle 阶段）对输出的 HTML 文件进行后处理，
+ * 压缩 JS 代码中的多行模板字符串，减小包体积。
+ *
+ * 这个插件必须在 vite-plugin-singlefile 之后运行，
+ * 因为它直接处理最终输出的文件，而不是通过 Vite 的 HTML 处理管道。
+ */
+import type { Plugin } from 'vite';
+export interface TemplateMinifierOptions {
+    /** 输出目录 */
+    outputDir: string;
+    /** 是否启用（默认 true） */
+    enabled?: boolean;
+}
+/**
+ * 创建模板字符串压缩插件
+ */
+export declare function viteTemplateMinifierPlugin(options: TemplateMinifierOptions): Plugin;