pixifact-cli 0.6.0 → 0.7.0

package/editor/assets/init-CuKNsO_k.js

@@ -0,0 +1 @@
+import{n as e,r as t,t as n,u as r}from"./index-DoPhYWF1.js";r.add(n,t),r.add(e);

package/editor/assets/webworkerAll-DM9kdU0t.js

@@ -0,0 +1 @@
+import"./index-DoPhYWF1.js";import"./init-CuKNsO_k.js";

package/editor/index.html

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Pixifact Editor</title>
-    <script type="module" crossorigin src="/assets/index-D8cbY_GQ.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-gCKoe0w8.css">
+    <script type="module" crossorigin src="/assets/index-DoPhYWF1.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-D3t5XxiB.css">
   </head>
   <body>
     <div id="app"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pixifact-cli",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Pixifact Scene 自动化 CLI。",
   "packageManager": "bun@1.3.13",
   "type": "module",
@@ -32,7 +32,7 @@
     "start": "bun src/pixifact-cli.ts"
   },
   "dependencies": {
-    "esbuild": "^0.27.2",
-    "pixifact": "^0.6.0"
+    "pixifact": "^0.7.0",
+    "vite": "^8.0.10"
   }
 }

package/src/automation.ts

@@ -465,7 +465,7 @@ function walkFiles(root: string, directory: string, depth: number, maxDepth: num
 
     for (const entry of entries) {
         const absolute = path.join(directory, entry.name);
-        const relative = path.relative(root, absolute);
+        const relative = toPosixPath(path.relative(root, absolute));
         if (entry.isDirectory()) {
             results.push({
                 path: relative,

package/src/editorServer.ts

@@ -274,7 +274,12 @@ export function watchEditorProject(projectRoot: string, onProjectFileChanged: (p
     const changedPathTimers = new Map<string, ReturnType<typeof setTimeout>>();
     const watcher = fs.watch(projectRoot, { recursive: true }, (_event, fileName) => {
         if (!fileName) return;
-        const changedPath = String(fileName).split(path.sep).join('/');
+        const filePath = String(fileName);
+        const absolutePath = path.resolve(projectRoot, filePath);
+        if (fs.existsSync(absolutePath) && fs.statSync(absolutePath).isDirectory()) {
+            return;
+        }
+        const changedPath = filePath.split(path.sep).join('/');
         const pending = changedPathTimers.get(changedPath);
         if (pending) clearTimeout(pending);
         changedPathTimers.set(changedPath, setTimeout(() => {

package/src/pixifact-cli.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 import fs from 'node:fs';
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { createPixifactAutomation } from './automation';
 import { hintForCommandError } from 'pixifact';
 import { CompileSceneError, compileScenes } from 'pixifact/compiler-node';
@@ -10,19 +11,19 @@ import { captureEditorScreenshot, queryEditorContext } from './editorSession';
 import { queryRuntime, queryRuntimeList } from './runtimeSession';
 import type { RuntimeLogLevel, RuntimeRequest } from 'pixifact/runtime-dev';
 import {
-    buildWechatTarget,
-    devWechatTarget,
-    validateWechatTarget,
-    type WechatDevEvent,
-    WechatTargetError,
-} from './wechatTarget';
+    buildPixifactTarget,
+    devPixifactTarget,
+    validatePixifactTarget,
+    type PixifactDevEvent,
+    PixifactTargetError,
+} from './viteTarget';
 
 type Automation = ReturnType<typeof createPixifactAutomation>;
 
 interface CliOptions {
     automation?: Automation;
     captureEditorScreenshot?: typeof captureEditorScreenshot;
-    onWechatDevEvent?: (event: WechatDevEvent) => void;
+    onDevEvent?: (event: PixifactDevEvent) => void;
     readEditorContext?: typeof queryEditorContext;
     listRuntimes?: typeof queryRuntimeList;
     queryRuntime?: typeof queryRuntime;
@@ -94,6 +95,17 @@ function optionalFlag(flags: Record<string, string | true>, name: string) {
     return value === undefined ? undefined : requireFlag(flags, name);
 }
 
+function assertAllowedFlags(
+    flags: Record<string, string | true>,
+    allowed: readonly string[],
+    command: string,
+) {
+    const unexpected = Object.keys(flags).find((name) => !allowed.includes(name));
+    if (unexpected !== undefined) {
+        throw new Error(`Unknown option "--${unexpected}" for Pixifact ${command}.`);
+    }
+}
+
 function finiteNumberFlag(flags: Record<string, string | true>, name: string) {
     const value = Number(requireFlag(flags, name));
     if (!Number.isFinite(value)) throw new Error(`--${name} must be a finite number.`);
@@ -256,7 +268,7 @@ async function executeFileCommand(
     positionals: string[],
     flags: Record<string, string | true>,
     automation: Automation,
-    onWechatDevEvent?: (event: WechatDevEvent) => void,
+    onDevEvent?: (event: PixifactDevEvent) => void,
     startEditor: typeof startEditorServer = startEditorServer,
     readEditorContext: typeof queryEditorContext = queryEditorContext,
     captureScreenshot: typeof captureEditorScreenshot = captureEditorScreenshot,
@@ -371,68 +383,61 @@ async function executeFileCommand(
     }
 
     if ((area === 'build' || area === 'dev' || area === 'validate') && action === undefined) {
-        const target = requireFlag(flags, 'target');
-        if (target !== 'wechat') {
-            throw new Error(`Unknown Pixifact target "${target}".`);
-        }
+        assertAllowedFlags(flags, ['mode', 'project-root'], area);
+        const mode = flags.mode === undefined
+            ? area === 'dev' ? 'development' : 'production'
+            : requireFlag(flags, 'mode');
         if (area === 'validate') {
-            const result = await validateWechatTarget(projectRoot);
+            const result = await validatePixifactTarget(projectRoot, mode);
             return result.diagnostics.length > 0
                 ? {
                     ok: false,
-                    target,
+                    mode,
+                    platform: result.platform,
                     diagnostics: result.diagnostics,
-                    hint: 'Fix the listed WeChat target diagnostics, then validate again.',
+                    hint: 'Fix the listed target diagnostics, then validate again.',
                 }
-                : { ok: true, projectRoot, target };
+                : { ok: true, projectRoot, mode, platform: result.platform };
         }
         if (area === 'dev') {
-            if (flags.mode !== undefined) {
-                throw new Error('dev --target wechat always uses development mode; remove --mode.');
-            }
             try {
-                const session = await devWechatTarget(projectRoot, onWechatDevEvent);
+                const session = await devPixifactTarget(projectRoot, mode, onDevEvent);
                 return {
                     ok: true,
                     projectRoot,
-                    target,
-                    mode: 'development',
+                    platform: session.platform,
+                    mode,
                     watching: true,
                     report: session.initialReport,
                 };
             } catch (error) {
-                if (error instanceof WechatTargetError) {
+                if (error instanceof PixifactTargetError) {
                     return {
                         ok: false,
-                        target,
                         error: error.message,
                         diagnostics: error.diagnostics,
-                        hint: 'Fix the listed WeChat target diagnostics, then start dev again.',
+                        hint: 'Fix the listed target diagnostics, then start dev again.',
                     };
                 }
                 throw error;
             }
         }
-        const mode = flags.mode === undefined ? 'production' : requireFlag(flags, 'mode');
-        if (mode !== 'development' && mode !== 'production') {
-            throw new Error('--mode must be development or production.');
-        }
         try {
+            const report = await buildPixifactTarget(projectRoot, mode);
             return {
                 ok: true,
                 projectRoot,
-                target,
+                platform: report.platform,
                 mode,
-                report: await buildWechatTarget(projectRoot, mode),
+                report,
             };
         } catch (error) {
-            if (error instanceof WechatTargetError) {
+            if (error instanceof PixifactTargetError) {
                 return {
                     ok: false,
-                    target,
                     error: error.message,
                     diagnostics: error.diagnostics,
-                    hint: 'Fix the listed WeChat target diagnostics, then build again.',
+                    hint: 'Fix the listed target diagnostics, then build again.',
                 };
             }
             throw error;
@@ -510,9 +515,9 @@ export async function executePixifactCli(argv: string[], options: CliOptions = {
                         'scene inspect --scene <scene-path>',
                         'scene validate --scene <scene-path>',
                         'compile-scenes',
-                        'validate --target wechat',
-                        'build --target wechat',
-                        'dev --target wechat',
+                        'validate [--mode <vite-mode>]',
+                        'build [--mode <vite-mode>]',
+                        'dev [--mode <vite-mode>]',
                     ],
                     aiValidationAlternatives: [
                         'scene validate --all',
@@ -550,7 +555,7 @@ export async function executePixifactCli(argv: string[], options: CliOptions = {
             parsed.positionals,
             parsed.flags,
             automation,
-            options.onWechatDevEvent,
+            options.onDevEvent,
             options.startEditor,
             options.readEditorContext,
             options.captureEditorScreenshot,
@@ -582,9 +587,9 @@ export async function executePixifactCli(argv: string[], options: CliOptions = {
     }
 }
 
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
     const result = await executePixifactCli(process.argv.slice(2), {
-        onWechatDevEvent: (event) => process.stdout.write(jsonLine(event)),
+        onDevEvent: (event) => process.stdout.write(jsonLine(event)),
     });
     process.stdout.write(result.stdout);
     process.stderr.write(result.stderr);

package/src/viteTarget.ts

@@ -0,0 +1,323 @@
+import { access, readFile, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import {
+    build,
+    createServer,
+    resolveConfig,
+    type Rollup,
+} from 'vite';
+import {
+    parsePixifactProjectConfig,
+    pixifactProjectConfigFileName,
+    type PixifactProjectConfig,
+} from 'pixifact';
+import {
+    compilerSceneNodeLocator,
+    parseSceneTemplate,
+    type SceneTemplateNode,
+} from 'pixifact/compiler';
+import {
+    loadPixifactEnv,
+    pixifactBuildReporter,
+    type PixifactBuildReport,
+    type PixifactPlatform,
+} from 'pixifact/compiler-node';
+
+export interface PixifactTargetDiagnostic {
+    asset?: string;
+    message: string;
+    node?: string;
+    scene?: string;
+}
+
+export type PixifactDevEvent = {
+    type: 'built';
+    report: PixifactBuildReport;
+} | {
+    type: 'error';
+    error: string;
+};
+
+export interface PixifactDevSession {
+    close(): Promise<void>;
+    initialReport: PixifactBuildReport;
+    platform: PixifactPlatform;
+}
+
+export class PixifactTargetError extends Error {
+    constructor(
+        message: string,
+        readonly diagnostics: PixifactTargetDiagnostic[],
+    ) {
+        super(message);
+        this.name = 'PixifactTargetError';
+    }
+}
+
+export async function validatePixifactTarget(projectRootInput: string, mode: string) {
+    const projectRoot = path.resolve(projectRootInput);
+    const { platform } = loadPixifactEnv(projectRoot, mode);
+    const config = parsePixifactProjectConfig(JSON.parse(await readFile(
+        path.join(projectRoot, pixifactProjectConfigFileName),
+        'utf8',
+    )));
+    const diagnostics = await collectDiagnostics(projectRoot, config, platform);
+    const resolved = await resolveConfig({ root: projectRoot, mode, logLevel: 'silent' }, 'build', mode);
+    const pluginNames = new Set(resolved.plugins.map((plugin) => plugin.name));
+    for (const name of [
+        'pixifact-scenes',
+        'pixifact-platform',
+        'pixifact-assets',
+        'pixifact-resources',
+        'pixifact-minigame',
+    ]) {
+        if (!pluginNames.has(name)) {
+            diagnostics.push({ message: `vite.config.ts must include pixifact(); missing ${name}.` });
+            break;
+        }
+    }
+    if (platform !== 'web') {
+        const packageName = `@pixifact/platform-${platform}`;
+        const resolve = resolved.createResolver();
+        if (!await resolve(packageName, path.join(projectRoot, 'src/main.ts'))) {
+            diagnostics.push({
+                message: `缺少 ${packageName}；请运行 bun add ${packageName}。`,
+            });
+        }
+    }
+    return { config, diagnostics, mode, platform, projectRoot, resolved };
+}
+
+export async function buildPixifactTarget(
+    projectRootInput: string,
+    mode: string,
+): Promise<PixifactBuildReport> {
+    const validation = await validatePixifactTarget(projectRootInput, mode);
+    if (validation.diagnostics.length > 0) {
+        throw new PixifactTargetError('Pixifact target validation failed.', validation.diagnostics);
+    }
+    let report: PixifactBuildReport | undefined;
+    await build({
+        root: validation.projectRoot,
+        mode,
+        logLevel: 'silent',
+        plugins: [pixifactBuildReporter(validation.platform, (value) => {
+            report = value;
+        })],
+    });
+    if (!report) throw new Error('Vite completed without a Pixifact build report.');
+    return report;
+}
+
+export async function devPixifactTarget(
+    projectRootInput: string,
+    mode: string,
+    onEvent: (event: PixifactDevEvent) => void = () => undefined,
+): Promise<PixifactDevSession> {
+    const validation = await validatePixifactTarget(projectRootInput, mode);
+    if (validation.diagnostics.length > 0) {
+        throw new PixifactTargetError('Pixifact target validation failed.', validation.diagnostics);
+    }
+    if (validation.platform === 'web') {
+        const server = await createServer({
+            root: validation.projectRoot,
+            mode,
+            logLevel: 'silent',
+        });
+        await server.listen();
+        return {
+            close: () => server.close(),
+            initialReport: emptyReport('web', validation.resolved.build.outDir),
+            platform: 'web',
+        };
+    }
+    let resolveInitial: (report: PixifactBuildReport) => void;
+    let rejectInitial: (error: Error) => void;
+    const initial = new Promise<PixifactBuildReport>((resolve, reject) => {
+        resolveInitial = resolve;
+        rejectInitial = reject;
+    });
+    let first = true;
+    let completedReport: PixifactBuildReport | undefined;
+    const watcher = await build({
+        root: validation.projectRoot,
+        mode,
+        logLevel: 'silent',
+        build: { watch: {} },
+        plugins: [pixifactBuildReporter(validation.platform, (report) => {
+            completedReport = report;
+        })],
+    }) as Rollup.RollupWatcher;
+    watcher.on('event', (event) => {
+        if (event.code === 'END' && completedReport) {
+            const report = completedReport;
+            completedReport = undefined;
+            if (first) {
+                first = false;
+                resolveInitial(report);
+            } else {
+                onEvent({ type: 'built', report });
+            }
+        } else if (event.code === 'ERROR') {
+            const error = event.error instanceof Error ? event.error : new Error(String(event.error));
+            if (first) {
+                first = false;
+                rejectInitial(error);
+            } else {
+                onEvent({ type: 'error', error: error.message });
+            }
+        }
+    });
+    return {
+        close: () => watcher.close(),
+        initialReport: await initial,
+        platform: validation.platform,
+    };
+}
+
+async function collectDiagnostics(
+    projectRoot: string,
+    config: PixifactProjectConfig,
+    platform: PixifactPlatform,
+) {
+    const diagnostics: PixifactTargetDiagnostic[] = [];
+    await requireFile(projectRoot, 'src/main.ts', diagnostics, '应用入口 src/main.ts 不存在。');
+    if (platform !== 'web') {
+        await requireFile(projectRoot, `platforms/${platform}/game.json`, diagnostics, `${platform} game.json 不存在。`);
+        await requireFile(
+            projectRoot,
+            `platforms/${platform}/project.config.json`,
+            diagnostics,
+            `${platform} project.config.json 不存在。`,
+        );
+    }
+    for (const pack of config.resourcePacks ?? []) {
+        const root = path.join(projectRoot, 'resources', pack);
+        if (!await isDirectory(root)) {
+            diagnostics.push({ asset: `resources/${pack}`, message: `资源包 ${pack} 的目录不存在。` });
+            continue;
+        }
+        if (platform !== 'web') {
+            for (const file of await collectFiles(root)) {
+                if (path.extname(file).toLowerCase() === '.svg') {
+                    diagnostics.push({
+                        asset: projectPath(projectRoot, file),
+                        message: `${platform} 小游戏不支持 SVG 资源。`,
+                    });
+                }
+            }
+        }
+    }
+    for (const scene of Object.values(config.scenes)) {
+        if (!await exists(path.join(projectRoot, scene))) {
+            diagnostics.push({ asset: scene, message: 'Scene 文件不存在。' });
+            continue;
+        }
+        if (platform === 'web') continue;
+        const template = parseSceneTemplate(await readFile(path.join(projectRoot, scene), 'utf8'));
+        await collectSceneDiagnostics(template.children, scene, '', projectRoot, platform, diagnostics);
+    }
+    if (platform !== 'web') {
+        const gameJsonPath = path.join(projectRoot, 'platforms', platform, 'game.json');
+        if (await exists(gameJsonPath)) {
+            const gameJson = JSON.parse(await readFile(gameJsonPath, 'utf8')) as Record<string, unknown>;
+            const property = platform === 'wechat' ? 'subpackages' : 'subPackages';
+            if (gameJson[property] !== undefined) {
+                diagnostics.push({
+                    asset: `platforms/${platform}/game.json`,
+                    message: `${property} 由 Pixifact 根据 resourcePacks 生成，不能在源模板中重复声明。`,
+                });
+            }
+        }
+    }
+    return diagnostics;
+}
+
+async function collectSceneDiagnostics(
+    nodes: SceneTemplateNode[],
+    scene: string,
+    parentPath: string,
+    projectRoot: string,
+    platform: Exclude<PixifactPlatform, 'web'>,
+    diagnostics: PixifactTargetDiagnostic[],
+) {
+    for (const [index, node] of nodes.entries()) {
+        const nodePath = parentPath ? `${parentPath}/${index}` : String(index);
+        if (node.kind === 'slotOutlet') continue;
+        if (node.kind === 'sceneInstance') {
+            for (const [slotName, children] of Object.entries(node.slots)) {
+                await collectSceneDiagnostics(children, scene, `${nodePath}/slot:${slotName}`, projectRoot, platform, diagnostics);
+            }
+            continue;
+        }
+        const locator = compilerSceneNodeLocator(node, nodePath);
+        if (node.type === 'HTMLText' || node.type === 'DOMContainer') {
+            diagnostics.push({ message: `${platform} 小游戏不支持 ${node.type}。`, node: locator, scene });
+        }
+        if (typeof node.props.texture === 'string') {
+            const texture = node.props.texture;
+            const extension = path.extname(texture).toLowerCase();
+            if (!isProjectAssetPath(texture)) {
+                diagnostics.push({ asset: texture, message: `${platform} 小游戏 Scene 纹理必须使用项目相对路径。`, node: locator, scene });
+            } else if (!['.jpeg', '.jpg', '.png', '.webp'].includes(extension)) {
+                diagnostics.push({ asset: texture, message: `${platform} 小游戏 Scene 纹理不支持 ${extension || '无扩展名'} 格式。`, node: locator, scene });
+            } else if (!await exists(path.join(projectRoot, texture))) {
+                diagnostics.push({ asset: texture, message: `${platform} 小游戏 Scene 纹理文件不存在。`, node: locator, scene });
+            }
+        }
+        await collectSceneDiagnostics(node.children, scene, nodePath, projectRoot, platform, diagnostics);
+    }
+}
+
+function isProjectAssetPath(value: string) {
+    return value.trim() !== ''
+        && !value.startsWith('/')
+        && !value.startsWith('./')
+        && !value.includes('\\')
+        && !value.split('/').includes('..')
+        && !/^[a-zA-Z][a-zA-Z\d+.-]*:/.test(value);
+}
+
+async function requireFile(
+    projectRoot: string,
+    relativePath: string,
+    diagnostics: PixifactTargetDiagnostic[],
+    message: string,
+) {
+    if (!await exists(path.join(projectRoot, relativePath))) diagnostics.push({ asset: relativePath, message });
+}
+
+async function collectFiles(root: string): Promise<string[]> {
+    const files: string[] = [];
+    for (const entry of await readdir(root, { withFileTypes: true })) {
+        const absolute = path.join(root, entry.name);
+        if (entry.isDirectory()) files.push(...await collectFiles(absolute));
+        else if (entry.isFile()) files.push(absolute);
+    }
+    return files;
+}
+
+async function exists(filePath: string) {
+    try {
+        await access(filePath);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function isDirectory(filePath: string) {
+    try {
+        return (await stat(filePath)).isDirectory();
+    } catch {
+        return false;
+    }
+}
+
+function emptyReport(platform: PixifactPlatform, outputDirectory: string): PixifactBuildReport {
+    return { mainPackageBytes: 0, outputDirectory, platform, subpackages: {}, totalPackageBytes: 0 };
+}
+
+function projectPath(root: string, filePath: string) {
+    return path.relative(root, filePath).replaceAll(path.sep, '/');
+}

package/editor/assets/browserAll-DCAvtrKG.js

@@ -1 +0,0 @@
-import{a as e,c as t,i as n,l as r,o as i,s as a,u as o}from"./index-D8cbY_GQ.js";import"./init-ClFt_GA_.js";o.add(t),o.mixin(r,a),o.add(i),o.add(e),o.mixin(r,n);

package/editor/assets/init-ClFt_GA_.js

@@ -1 +0,0 @@
-import{n as e,r as t,t as n,u as r}from"./index-D8cbY_GQ.js";r.add(n,t),r.add(e);

package/editor/assets/webworkerAll-Do_n5w1y.js

@@ -1 +0,0 @@
-import"./index-D8cbY_GQ.js";import"./init-ClFt_GA_.js";