@playcraft/build 0.0.2

package/dist/vite/plugin-platform.js

@@ -0,0 +1,241 @@
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+import archiver from 'archiver';
+import { createWriteStream } from 'fs';
+import { PLATFORM_CONFIGS } from './platform-configs.js';
+/**
+ * 平台 Vite 插件
+ * 注入平台特定代码和处理输出格式
+ */
+export function vitePlatformPlugin(options) {
+    return {
+        name: 'vite-plugin-platform',
+        enforce: 'post',
+        transformIndexHtml: {
+            order: 'post',
+            async handler(html) {
+                // 使用平台适配器修改 HTML
+                let output = options.adapter.modifyHTML(html, []);
+                if (options.mraidSupport) {
+                    output = await injectMraidResizePatch(output);
+                }
+                return output;
+            },
+        },
+        async closeBundle() {
+            // 如果需要 ZIP 格式，在构建完成后打包
+            const platformConfig = PLATFORM_CONFIGS[options.platform];
+            // 仅多文件输出需要复制基础资源
+            if (options.outputFormat === 'zip') {
+                await copyBaseBuildAssets(options.baseBuildDir, options.outputDir);
+                if (options.mraidSupport) {
+                    await applyMraidSupport(options.outputDir);
+                }
+                if (options.externFiles?.enabled) {
+                    await applyExternFiles(options.outputDir, options.externFiles);
+                }
+            }
+            if (options.outputFormat === 'html') {
+                await keepSingleHtml(options.outputDir, platformConfig.outputFileName);
+            }
+            if (platformConfig.outputFormat === 'zip') {
+                // 使用 Promise 处理异步操作
+                createZipOutput(options.outputDir, platformConfig.outputFileName).catch((err) => {
+                    console.error('创建 ZIP 文件失败:', err);
+                });
+            }
+        },
+    };
+}
+/**
+ * 创建 ZIP 输出
+ */
+function createZipOutput(outDir, htmlFileName) {
+    return new Promise(async (resolve, reject) => {
+        const zipPath = path.join(outDir, 'playable.zip');
+        const output = createWriteStream(zipPath);
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        output.on('close', () => {
+            console.log(`✅ ZIP 文件已创建: ${zipPath} (${archive.pointer()} bytes)`);
+            resolve();
+        });
+        archive.on('error', (err) => {
+            reject(err);
+        });
+        archive.pipe(output);
+        // 添加输出目录全部内容（排除 zip 本身）
+        archive.glob('**/*', {
+            cwd: outDir,
+            ignore: ['playable.zip'],
+        });
+        archive.finalize();
+    });
+}
+async function keepSingleHtml(outDir, htmlFileName) {
+    let entries = [];
+    try {
+        entries = await fs.readdir(outDir, { withFileTypes: true });
+    }
+    catch (error) {
+        return;
+    }
+    await Promise.all(entries.map(async (entry) => {
+        if (entry.name === htmlFileName) {
+            return;
+        }
+        const targetPath = path.join(outDir, entry.name);
+        await fs.rm(targetPath, { recursive: true, force: true });
+    }));
+}
+async function applyExternFiles(outDir, externFiles) {
+    const folderName = externFiles.folderName?.trim() || `playcraft-assets-${crypto.randomUUID()}`;
+    const externalPrefix = externFiles.externalUrlPrefix?.trim().replace(/\/+$/g, '');
+    const assetPrefix = externalPrefix ? `${externalPrefix}/${folderName}/` : `${folderName}/`;
+    const folderPath = path.join(outDir, folderName);
+    await fs.mkdir(folderPath, { recursive: true });
+    const entries = await fs.readdir(outDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.name === 'index.html' || entry.name === folderName) {
+            continue;
+        }
+        const srcPath = path.join(outDir, entry.name);
+        const destPath = path.join(folderPath, entry.name);
+        await fs.rename(srcPath, destPath);
+    }
+    await rewriteIndexHtml(outDir, assetPrefix);
+    await rewriteSettings(folderPath, assetPrefix);
+    await rewriteConfig(folderPath, assetPrefix);
+}
+async function rewriteIndexHtml(outDir, assetPrefix) {
+    const indexPath = path.join(outDir, 'index.html');
+    let html = await fs.readFile(indexPath, 'utf-8');
+    html = html.replace(/(<script[^>]*src=["'])([^"']+)(["'][^>]*><\/script>)/gi, (match, start, src, end) => {
+        if (src.startsWith('http') || src.startsWith('data:')) {
+            return match;
+        }
+        return `${start}${assetPrefix}${src}${end}`;
+    });
+    html = html.replace(/(<link[^>]*href=["'])([^"']+)(["'][^>]*>)/gi, (match, start, href, end) => {
+        if (href.startsWith('http') || href.startsWith('data:')) {
+            return match;
+        }
+        return `${start}${assetPrefix}${href}${end}`;
+    });
+    await fs.writeFile(indexPath, html);
+}
+async function rewriteSettings(folderPath, assetPrefix) {
+    const settingsPath = path.join(folderPath, '__settings__.js');
+    try {
+        let code = await fs.readFile(settingsPath, 'utf-8');
+        code = code.replace(/window\.ASSET_PREFIX\s*=\s*"[^"]*";/, `window.ASSET_PREFIX = "${assetPrefix}";`);
+        code = code.replace(/window\.SCRIPT_PREFIX\s*=\s*"[^"]*";/, `window.SCRIPT_PREFIX = "${assetPrefix}";`);
+        code = code.replace(/window\.CONFIG_FILENAME\s*=\s*"([^"]+)";/, (match, value) => {
+            if (value.startsWith('data:') || value.startsWith('http')) {
+                return match;
+            }
+            return `window.CONFIG_FILENAME = "${assetPrefix}${value}";`;
+        });
+        code = code.replace(/window\.SCENE_PATH\s*=\s*"([^"]*)";/, (match, value) => {
+            if (!value || value.startsWith('data:') || value.startsWith('http')) {
+                return match;
+            }
+            return `window.SCENE_PATH = "${assetPrefix}${value}";`;
+        });
+        await fs.writeFile(settingsPath, code);
+    }
+    catch (error) {
+        // 忽略缺失
+    }
+}
+async function rewriteConfig(folderPath, assetPrefix) {
+    const configPath = path.join(folderPath, 'config.json');
+    try {
+        const raw = await fs.readFile(configPath, 'utf-8');
+        const json = JSON.parse(raw);
+        if (Array.isArray(json.scenes)) {
+            json.scenes = json.scenes.map((scene) => {
+                if (!scene?.url || scene.url.startsWith('http') || scene.url.startsWith('data:')) {
+                    return scene;
+                }
+                return { ...scene, url: `${assetPrefix}${scene.url}` };
+            });
+        }
+        await fs.writeFile(configPath, JSON.stringify(json));
+    }
+    catch (error) {
+        // 忽略缺失
+    }
+}
+async function applyMraidSupport(outDir) {
+    await patchConfigFillMode(outDir);
+    await patchStylesForMraid(outDir);
+}
+async function patchConfigFillMode(outDir) {
+    const configPath = path.join(outDir, 'config.json');
+    try {
+        const raw = await fs.readFile(configPath, 'utf-8');
+        const json = JSON.parse(raw);
+        json.application_properties = {
+            ...(json.application_properties || {}),
+            fillMode: 'NONE',
+        };
+        await fs.writeFile(configPath, JSON.stringify(json));
+    }
+    catch (error) {
+        // 忽略缺失
+    }
+}
+async function patchStylesForMraid(outDir) {
+    const cssPath = path.join(outDir, 'styles.css');
+    try {
+        let css = await fs.readFile(cssPath, 'utf-8');
+        if (!css.includes('fill-mode-NONE')) {
+            css += '\n#application-canvas.fill-mode-NONE { margin: 0; width: 100%; height: 100%; }\n';
+            await fs.writeFile(cssPath, css);
+        }
+    }
+    catch (error) {
+        // 忽略缺失
+    }
+}
+async function injectMraidResizePatch(html) {
+    const patchCode = await readPatchFile('one-page-mraid-resize-canvas.js');
+    return html.replace('</head>', `<script>${patchCode}</script>\n</head>`);
+}
+async function readPatchFile(name) {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const patchPath = path.resolve(currentDir, '../../templates/patches', name);
+    return await fs.readFile(patchPath, 'utf-8');
+}
+async function copyBaseBuildAssets(baseBuildDir, outDir) {
+    const entries = await fs.readdir(baseBuildDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.name === 'index.html') {
+            continue;
+        }
+        const srcPath = path.join(baseBuildDir, entry.name);
+        const destPath = path.join(outDir, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirectory(srcPath, destPath);
+        }
+        else {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}
+async function copyDirectory(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirectory(srcPath, destPath);
+        }
+        else {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import type { Plugin } from 'vite';
+export interface PlayCanvasPluginOptions {
+    baseBuildDir: string;
+    inlineScripts: boolean;
+    convertDataUrls: boolean;
+    outputFormat: 'html' | 'zip';
+    patchXhrOut: boolean;
+    inlineGameScripts: boolean;
+    compressEngine: boolean;
+    configJsonInline: boolean;
+    mraidSupport: boolean;
+    ammoReplacement?: 'p2' | 'cannon';
+}
+/**
+ * PlayCanvas Vite 插件
+ * 处理 PlayCanvas 特定的资源转换和内联
+ */
+export declare function vitePlayCanvasPlugin(options: PlayCanvasPluginOptions): Plugin;