pixifact 0.6.1 → 0.8.0

package/dist/compiler-node/vite.js

@@ -1,48 +1,434 @@
-import { readFile } from 'node:fs/promises';
+import { access, readFile, readdir, stat } from 'node:fs/promises';
+import { realpathSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { generatedSceneAssetsFileName } from '../compiler/compileScenes.js';
-function projectRootPath(projectRoot) {
-    if (typeof projectRoot === 'string') {
-        return projectRoot;
-    }
-    if (projectRoot) {
-        return fileURLToPath(projectRoot);
-    }
-    return process.cwd();
+import { loadEnv, } from 'vite';
+import { parsePixifactProjectConfig, pixifactProjectConfigFileName, } from '../project/index.js';
+import { compileScenes, generatedSceneAssetsFileName } from '../compiler/compileScenes.js';
+const totalPackageLimit = 20 * 1024 * 1024;
+const mainPackageLimit = 4 * 1024 * 1024;
+const descriptors = {
+    wechat: {
+        ecmascriptTarget: 'es2020',
+        mainPackageLimit: () => mainPackageLimit,
+        module: '@pixifact/platform-wechat',
+        subpackageProperty: 'subpackages',
+        userAgent: 'WeChatMiniGame',
+    },
+    douyin: {
+        ecmascriptTarget: 'es2018',
+        mainPackageLimit: (hasSubpackages) => hasSubpackages ? mainPackageLimit : undefined,
+        module: '@pixifact/platform-douyin',
+        subpackageProperty: 'subPackages',
+        userAgent: 'DouyinMiniGame',
+    },
+};
+const virtualPlatformId = '\0pixifact:platform';
+const virtualAssetsId = '\0pixifact:assets';
+const virtualScenesId = '\0pixifact:scenes';
+export function pixifact(options = {}) {
+    const state = {};
+    return [
+        scenePlugin(state, options),
+        platformPlugin(state),
+        assetsPlugin(state),
+        resourcePlugin(state),
+        miniGamePlugin(state),
+    ];
 }
-export function pixifactScenesPlugin(options = {}) {
-    const projectRoot = projectRootPath(options.projectRoot);
-    const generatedDir = path.resolve(projectRoot, options.generatedDir ?? '.pixifact/generated');
-    const sceneRegistry = path.join(generatedDir, 'scenes.generated.ts');
-    const sceneAssets = path.join(generatedDir, generatedSceneAssetsFileName);
-    const virtualSceneRegistry = '\0pixifact:scenes';
+function scenePlugin(state, options) {
     return {
         name: 'pixifact-scenes',
+        async config(config, env) {
+            await configureState(state, options, config, env);
+            const projectRoot = required(state.projectRoot);
+            const platform = required(state.platform);
+            const output = platform === 'web'
+                ? {}
+                : miniGameBuildConfig(projectRoot, platform, config);
+            return {
+                ...output,
+                root: projectRoot,
+                resolve: {
+                    dedupe: config.resolve?.dedupe?.includes('pixi.js') ? [] : ['pixi.js'],
+                },
+                build: {
+                    outDir: path.resolve(projectRoot, config.build?.outDir ?? `dist/${platform}`),
+                    ...output.build,
+                },
+            };
+        },
+        configResolved(config) {
+            state.resolved = config;
+            state.projectRoot = config.root;
+            assertSafeOutputDirectory(config.root, config.build.outDir);
+        },
+        async buildStart() {
+            state.prepared = prepareProject(state);
+            const assets = await state.prepared;
+            for (const file of watchedFiles(state, assets)) {
+                this.addWatchFile(file);
+            }
+        },
         resolveId(id) {
-            return id === 'pixifact:scenes' ? virtualSceneRegistry : undefined;
+            return id === 'pixifact:scenes' ? virtualScenesId : undefined;
+        },
+        load(id) {
+            if (id !== virtualScenesId)
+                return undefined;
+            return `import ${JSON.stringify(viteFileImport(path.join(required(state.projectRoot), '.pixifact/generated/scenes.generated.ts')))};`;
+        },
+    };
+}
+function platformPlugin(state) {
+    return {
+        name: 'pixifact-platform',
+        resolveId(id) {
+            return id === 'pixifact:platform' ? virtualPlatformId : undefined;
+        },
+        load(id) {
+            if (id !== virtualPlatformId)
+                return undefined;
+            const platform = required(state.platform);
+            const module = platform === 'web' ? 'pixifact/platform/web' : descriptors[platform].module;
+            return `export { createApplication } from ${JSON.stringify(module)};`;
+        },
+    };
+}
+function assetsPlugin(state) {
+    return {
+        name: 'pixifact-assets',
+        resolveId(id) {
+            return id === 'pixifact:assets' ? virtualAssetsId : undefined;
         },
         async load(id) {
-            if (id !== virtualSceneRegistry) {
+            if (id !== virtualAssetsId)
                 return undefined;
+            const assets = await required(state.prepared);
+            return assetsModuleSource(state, assets);
+        },
+    };
+}
+function resourcePlugin(state) {
+    return {
+        name: 'pixifact-resources',
+        async buildStart() {
+            if (required(state.resolved).command !== 'build')
+                return;
+            const platform = required(state.platform);
+            for (const asset of await required(state.prepared)) {
+                if (!asset.pack || asset.remoteBaseUrl)
+                    continue;
+                const fileName = platform === 'web'
+                    ? asset.logicalPath
+                    : path.posix.join('subpackages', asset.pack, required(asset.relativePath));
+                this.emitFile({
+                    type: 'asset',
+                    fileName,
+                    source: await readFile(asset.absolutePath),
+                });
+            }
+            if (platform !== 'web') {
+                for (const pack of localPacks(required(state.config))) {
+                    this.emitFile({
+                        type: 'asset',
+                        fileName: path.posix.join('subpackages', pack, 'game.js'),
+                        source: '// Pixifact asset-only subpackage.\n',
+                    });
+                }
+            }
+        },
+    };
+}
+function miniGamePlugin(state) {
+    return {
+        name: 'pixifact-minigame',
+        async buildStart() {
+            const platform = required(state.platform);
+            if (platform === 'web')
+                return;
+            await required(state.prepared);
+            const projectRoot = required(state.projectRoot);
+            const configDir = path.join(projectRoot, 'platforms', platform);
+            const descriptor = descriptors[platform];
+            const gameJson = JSON.parse(await readFile(path.join(configDir, 'game.json'), 'utf8'));
+            const projectConfig = JSON.parse(await readFile(path.join(configDir, 'project.config.json'), 'utf8'));
+            if (gameJson[descriptor.subpackageProperty] !== undefined) {
+                throw new Error(`platforms/${platform}/game.json must not declare ${descriptor.subpackageProperty}; Pixifact manages resource subpackages.`);
             }
-            const assets = JSON.parse(await readFile(sceneAssets, 'utf8'));
-            const imports = assets.map((asset, index) => `import __pixifactAsset${index + 1} from ${JSON.stringify(viteFileImport(path.resolve(projectRoot, asset), '?url'))};`);
-            const manifest = Object.fromEntries(assets.map((asset, index) => [
-                asset,
-                { src: `__pixifactAsset${index + 1}` },
-            ]));
-            const manifestSource = JSON.stringify(manifest, null, 2)
-                .replace(/"src": "(__pixifactAsset\d+)"/g, '"src": $1');
-            return [
-                ...imports,
-                "import { configureSceneAssets } from 'pixifact/scene';",
-                `import ${JSON.stringify(viteFileImport(sceneRegistry))};`,
-                `configureSceneAssets(${manifestSource});`,
-            ].join('\n');
+            gameJson[descriptor.subpackageProperty] = localPacks(required(state.config)).map((name) => ({
+                name,
+                root: `subpackages/${name}`,
+            }));
+            projectConfig.appid = required(state.env).VITE_APP_ID;
+            this.emitFile({
+                type: 'asset',
+                fileName: 'game.json',
+                source: `${JSON.stringify(gameJson, null, 2)}\n`,
+            });
+            this.emitFile({
+                type: 'asset',
+                fileName: 'project.config.json',
+                source: `${JSON.stringify(projectConfig, null, 2)}\n`,
+            });
+        },
+        generateBundle(_options, bundle) {
+            const platform = required(state.platform);
+            if (platform === 'web')
+                return;
+            enforcePackageLimits(createBuildReport(platform, required(state.resolved).build.outDir, bundle));
+        },
+    };
+}
+export function pixifactBuildReporter(platform, onReport) {
+    let outputDirectory = '';
+    return {
+        name: 'pixifact-build-reporter',
+        configResolved(config) {
+            outputDirectory = config.build.outDir;
+        },
+        generateBundle(_options, bundle) {
+            onReport(createBuildReport(platform, outputDirectory, bundle));
+        },
+    };
+}
+export function loadPixifactEnv(projectRoot, mode) {
+    const env = loadEnv(mode, projectRoot, 'VITE_');
+    const platform = env.VITE_PLATFORM;
+    if (platform !== 'web' && platform !== 'wechat' && platform !== 'douyin') {
+        throw new Error('VITE_PLATFORM must be web, wechat, or douyin.');
+    }
+    if (platform !== 'web' && !env.VITE_APP_ID) {
+        throw new Error(`VITE_APP_ID is required for the ${platform} platform.`);
+    }
+    return { env, platform: platform };
+}
+async function configureState(state, options, config, env) {
+    const configuredRoot = options.projectRoot ?? config.root;
+    const projectRoot = realpathSync(path.resolve(projectRootPath(configuredRoot)));
+    const loaded = loadPixifactEnv(projectRoot, env.mode);
+    state.projectRoot = projectRoot;
+    state.mode = env.mode;
+    state.env = loaded.env;
+    state.platform = loaded.platform;
+    state.config = parsePixifactProjectConfig(JSON.parse(await readFile(path.join(projectRoot, pixifactProjectConfigFileName), 'utf8')));
+}
+function miniGameBuildConfig(projectRoot, platform, config) {
+    const descriptor = descriptors[platform];
+    return {
+        appType: 'custom',
+        experimental: {
+            ...config.experimental,
+            renderBuiltUrl: (filename) => filename,
+        },
+        publicDir: false,
+        build: {
+            assetsInlineLimit: 0,
+            modulePreload: false,
+            rollupOptions: {
+                ...config.build?.rollupOptions,
+                input: config.build?.rollupOptions?.input ?? path.join(projectRoot, 'src/main.ts'),
+                output: {
+                    ...(Array.isArray(config.build?.rollupOptions?.output)
+                        ? {}
+                        : config.build?.rollupOptions?.output),
+                    banner: [
+                        'var Intl=globalThis.Intl||{};',
+                        `var navigator=globalThis.navigator||(globalThis.navigator={gpu:null,userAgent:${JSON.stringify(descriptor.userAgent)}});`,
+                    ].join('\n'),
+                    entryFileNames: 'game.js',
+                    format: 'iife',
+                },
+            },
+            target: descriptor.ecmascriptTarget,
         },
     };
 }
+async function prepareProject(state) {
+    const projectRoot = required(state.projectRoot);
+    state.config = parsePixifactProjectConfig(JSON.parse(await readFile(path.join(projectRoot, pixifactProjectConfigFileName), 'utf8')));
+    await compileScenes({ projectRoot });
+    const config = required(state.config);
+    const sceneAssets = JSON.parse(await readFile(path.join(projectRoot, '.pixifact/generated', generatedSceneAssetsFileName), 'utf8'));
+    const assets = new Map();
+    for (const pack of config.resourcePacks ?? []) {
+        const root = path.join(projectRoot, 'resources', pack);
+        for (const absolutePath of await collectFiles(root)) {
+            const relativePath = projectPath(root, absolutePath);
+            const logicalPath = path.posix.join('resources', pack, relativePath);
+            assets.set(logicalPath, {
+                absolutePath,
+                logicalPath,
+                pack,
+                relativePath,
+                remoteBaseUrl: config.remoteResourcePacks?.[pack],
+            });
+        }
+    }
+    for (const logicalPath of sceneAssets) {
+        if (!assets.has(logicalPath)) {
+            assets.set(logicalPath, {
+                absolutePath: path.resolve(projectRoot, logicalPath),
+                logicalPath,
+            });
+        }
+    }
+    return [...assets.values()];
+}
+function assetsModuleSource(state, assets) {
+    const platform = required(state.platform);
+    const resolved = required(state.resolved);
+    const imports = [];
+    const sourceByPath = new Map();
+    for (const asset of assets) {
+        if (asset.remoteBaseUrl) {
+            sourceByPath.set(asset.logicalPath, JSON.stringify(`${asset.remoteBaseUrl}/${required(asset.relativePath)}`));
+        }
+        else if (asset.pack) {
+            if (platform === 'web' && resolved.command === 'serve') {
+                sourceByPath.set(asset.logicalPath, JSON.stringify(viteFileImport(asset.absolutePath)));
+            }
+            else {
+                const output = platform === 'web'
+                    ? asset.logicalPath
+                    : path.posix.join('subpackages', asset.pack, required(asset.relativePath));
+                sourceByPath.set(asset.logicalPath, platform === 'web'
+                    ? `import.meta.env.BASE_URL + ${JSON.stringify(output)}`
+                    : JSON.stringify(output));
+            }
+        }
+        else {
+            const identifier = `__pixifactAsset${imports.length + 1}`;
+            imports.push(`import ${identifier} from ${JSON.stringify(viteFileImport(asset.absolutePath, '?url'))};`);
+            sourceByPath.set(asset.logicalPath, identifier);
+        }
+    }
+    const bundles = (required(state.config).resourcePacks ?? []).map((name) => ({
+        name,
+        assets: assets.filter((asset) => asset.pack === name),
+    }));
+    const main = assets.filter((asset) => !asset.pack);
+    if (main.length > 0)
+        bundles.unshift({ name: '__pixifact_main__', assets: main });
+    const bundleSource = bundles.map((bundle) => `{
+        name: ${JSON.stringify(bundle.name)},
+        assets: [${bundle.assets.map((asset) => `{
+            alias: ${JSON.stringify(asset.logicalPath)},
+            src: ${required(sourceByPath.get(asset.logicalPath))},
+        }`).join(',')}],
+    }`).join(',');
+    return `${imports.join('\n')}\nconst manifest = { bundles: [${bundleSource}] };\nexport default manifest;\n`;
+}
+function watchedFiles(state, assets) {
+    const projectRoot = required(state.projectRoot);
+    const config = required(state.config);
+    const files = [
+        path.join(projectRoot, pixifactProjectConfigFileName),
+        ...Object.values(config.scenes).flatMap((scene) => [
+            path.join(projectRoot, scene),
+            path.join(projectRoot, scene.replace(/\.scene$/, '.ts')),
+        ]),
+        ...assets.map((asset) => asset.absolutePath),
+    ];
+    const platform = required(state.platform);
+    if (platform !== 'web') {
+        files.push(path.join(projectRoot, 'platforms', platform, 'game.json'), path.join(projectRoot, 'platforms', platform, 'project.config.json'));
+    }
+    return files;
+}
+function createBuildReport(platform, outputDirectory, bundle) {
+    const subpackages = {};
+    let mainPackageBytes = 0;
+    let totalPackageBytes = 0;
+    for (const output of Object.values(bundle)) {
+        if (output.fileName.endsWith('.map') || output.fileName === 'project.config.json')
+            continue;
+        const bytes = output.code === undefined
+            ? typeof output.source === 'string' ? Buffer.byteLength(output.source) : output.source?.byteLength ?? 0
+            : Buffer.byteLength(output.code);
+        const match = output.fileName.match(/^subpackages\/([^/]+)\//);
+        if (match) {
+            subpackages[match[1]] = (subpackages[match[1]] ?? 0) + bytes;
+        }
+        else {
+            mainPackageBytes += bytes;
+        }
+        totalPackageBytes += bytes;
+    }
+    return { mainPackageBytes, outputDirectory, platform, subpackages, totalPackageBytes };
+}
+function enforcePackageLimits(report) {
+    if (report.platform === 'web')
+        return;
+    const descriptor = descriptors[report.platform];
+    const limit = descriptor.mainPackageLimit(Object.keys(report.subpackages).length > 0);
+    if (limit !== undefined && report.mainPackageBytes > limit) {
+        throw new Error(`${report.platform} main package exceeds ${limit} bytes.`);
+    }
+    if (report.totalPackageBytes > totalPackageLimit) {
+        throw new Error(`${report.platform} total package exceeds ${totalPackageLimit} bytes.`);
+    }
+}
+function localPacks(config) {
+    return (config.resourcePacks ?? []).filter((name) => !config.remoteResourcePacks?.[name]);
+}
+function projectRootPath(projectRoot) {
+    if (typeof projectRoot === 'string')
+        return projectRoot;
+    if (projectRoot)
+        return fileURLToPath(projectRoot);
+    return process.cwd();
+}
+function assertSafeOutputDirectory(projectRoot, outputDirectory) {
+    const root = path.resolve(projectRoot);
+    const output = path.resolve(root, outputDirectory);
+    if (output === root || !output.startsWith(`${root}${path.sep}`)) {
+        throw new Error('Vite build.outDir must be a directory inside the project root.');
+    }
+    const relative = projectPath(root, output);
+    const inputRoots = ['.pixifact', 'platforms', 'resources', 'src'];
+    if (inputRoots.some((input) => relative === input || relative.startsWith(`${input}/`))) {
+        throw new Error('Vite build.outDir must not contain project inputs.');
+    }
+}
+async function collectFiles(root) {
+    if (!await isDirectory(root))
+        return [];
+    const files = [];
+    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 isDirectory(filePath) {
+    try {
+        return (await stat(filePath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function viteFileImport(filePath, suffix = '') {
     return `/@fs/${filePath.replaceAll(path.sep, '/')}${suffix}`;
 }
+function projectPath(root, filePath) {
+    return path.relative(root, filePath).replaceAll(path.sep, '/');
+}
+function required(value) {
+    if (value === undefined)
+        throw new Error('Pixifact Vite plugin state is not ready.');
+    return value;
+}

package/dist/errors.d.ts

@@ -1 +1 @@
-export declare function hintForCommandError(error: string): "Use a project-relative scene path that stays inside projectRoot." | "Choose a different scene path or inspect the existing file before writing." | "Use one of: button, progressBar, scrollView, loginForm." | "Run scene inspect --scene <scene-path> and pass one of the returned node locator values." | "Inspect the current project state again before regenerating the command." | "Choose a container node as the parent, or create a container template before adding children." | "Verify that the field belongs to the target node or component schema before retrying." | "Check the target schema and send a value with the expected type." | undefined;
+export declare function hintForCommandError(error: string): "Install the WeChat platform package with: bun add @pixifact/platform-wechat" | "Install the Douyin platform package with: bun add @pixifact/platform-douyin" | "Use a project-relative scene path that stays inside projectRoot." | "Choose a different scene path or inspect the existing file before writing." | "Use one of: button, progressBar, scrollView, loginForm." | "Run scene inspect --scene <scene-path> and pass one of the returned node locator values." | "Inspect the current project state again before regenerating the command." | "Choose a container node as the parent, or create a container template before adding children." | "Verify that the field belongs to the target node or component schema before retrying." | "Check the target schema and send a value with the expected type." | undefined;

package/dist/errors.js

@@ -1,4 +1,10 @@
 export function hintForCommandError(error) {
+    if (error.includes('@pixifact/platform-wechat')) {
+        return 'Install the WeChat platform package with: bun add @pixifact/platform-wechat';
+    }
+    if (error.includes('@pixifact/platform-douyin')) {
+        return 'Install the Douyin platform package with: bun add @pixifact/platform-douyin';
+    }
     if (error.includes('inside projectRoot')) {
         return 'Use a project-relative scene path that stays inside projectRoot.';
     }

package/dist/platform/{wechat → minigame}/adapter.d.ts

@@ -1,8 +1,8 @@
-import { fetchWechatResource } from './fetch.js';
-import type { WechatRuntime } from './runtime.js';
-export declare function createWechatPixiAdapter(runtime: WechatRuntime): {
-    createCanvas(width?: number, height?: number): import("./types").WechatCanvas;
-    createImage: () => import("./types").WechatImage;
+import type { MiniGameApi, MiniGameFetch } from './types.js';
+import type { MiniGameRuntime } from './runtime.js';
+export declare function createMiniGamePixiAdapter(api: MiniGameApi, runtime: MiniGameRuntime, fetchResource: MiniGameFetch): {
+    createCanvas(width?: number, height?: number): import("./types").MiniGameCanvas;
+    createImage: () => import("./types").MiniGameImage;
     getCanvasRenderingContext2D: () => ObjectConstructor;
     getWebGLRenderingContext: () => {
         new (): WebGLRenderingContext;
@@ -311,6 +311,7 @@ export declare function createWechatPixiAdapter(runtime: WechatRuntime): {
     };
     getBaseUrl: () => string;
     getFontFaceSet: () => null;
-    fetch: typeof fetchWechatResource;
+    fetch: MiniGameFetch;
     parseXML: () => Document;
 };
+export declare function installMiniGamePixiAdapter(api: MiniGameApi, runtime: MiniGameRuntime, fetchResource: MiniGameFetch): Promise<void>;

package/dist/platform/{wechat → minigame}/adapter.js

@@ -1,26 +1,28 @@
-import { fetchWechatResource } from './fetch.js';
-import { wechatApi } from './types.js';
-export function createWechatPixiAdapter(runtime) {
-    const wx = wechatApi();
+export function createMiniGamePixiAdapter(api, runtime, fetchResource) {
     const webGL1Constructor = globalThis.WebGLRenderingContext
         ?? (runtime.webGLVersion === 1 ? runtime.context.constructor : class WebGLRenderingContextFallback {
         });
     return {
         createCanvas(width = 1, height = 1) {
-            const canvas = wx.createOffscreenCanvas?.({ type: '2d', width, height }) ?? wx.createCanvas();
+            const canvas = api.createOffscreenCanvas?.({ type: '2d', width, height }) ?? api.createCanvas();
             canvas.width = width;
             canvas.height = height;
             return canvas;
         },
-        createImage: () => wx.createImage(),
+        createImage: () => api.createImage(),
         getCanvasRenderingContext2D: () => Object,
         getWebGLRenderingContext: () => webGL1Constructor,
         getNavigator: () => ({ gpu: null, userAgent: runtime.userAgent }),
         getBaseUrl: () => '',
         getFontFaceSet: () => null,
-        fetch: fetchWechatResource,
+        fetch: fetchResource,
         parseXML: () => {
-            throw new Error('XML parsing is not implemented for the WeChat target.');
+            throw new Error('XML parsing is not implemented for the Mini Game target.');
         },
     };
 }
+export async function installMiniGamePixiAdapter(api, runtime, fetchResource) {
+    const { DOMAdapter, loadTextures } = await import('pixi.js');
+    DOMAdapter.set(createMiniGamePixiAdapter(api, runtime, fetchResource));
+    loadTextures.config.preferCreateImageBitmap = false;
+}

package/dist/platform/minigame/application.d.ts

@@ -0,0 +1,4 @@
+import type { Application, ApplicationOptions } from 'pixi.js';
+import { type MiniGameTouchCoordinates } from './input.js';
+import type { MiniGameApi, MiniGameFetch } from './types.js';
+export declare function createMiniGameApplication(api: MiniGameApi, userAgent: string, fetchResource: MiniGameFetch, coordinates: MiniGameTouchCoordinates, options?: Partial<ApplicationOptions>): Promise<Application>;

package/dist/platform/minigame/application.js

@@ -0,0 +1,53 @@
+import { installMiniGamePixiAdapter } from './adapter.js';
+import { bindMiniGameLifecycle } from './lifecycle.js';
+import { bindMiniGamePointerEvents } from './input.js';
+import { createMiniGameRuntime } from './runtime.js';
+export async function createMiniGameApplication(api, userAgent, fetchResource, coordinates, options = {}) {
+    await Promise.all([
+        import('pixi.js/unsafe-eval'),
+        import('pixi.js/events'),
+    ]);
+    const { Application } = await import('pixi.js');
+    const runtime = createMiniGameRuntime(api, userAgent);
+    await installMiniGamePixiAdapter(api, runtime, fetchResource);
+    const app = new Application();
+    await app.init({
+        antialias: true,
+        ...options,
+        autoDensity: false,
+        canvas: runtime.canvas,
+        context: runtime.context,
+        eventFeatures: options.eventFeatures ?? {
+            click: true,
+            globalMove: true,
+            move: true,
+            wheel: false,
+        },
+        height: runtime.height,
+        preference: 'webgl',
+        resolution: options.resolution ?? runtime.resolution,
+        skipExtensionImports: true,
+        width: runtime.width,
+    });
+    const events = app.renderer.events;
+    const sink = {
+        pointerdown: (event) => events._onPointerDown(event),
+        pointermove: (event) => events._onPointerMove(event),
+        pointerup: (event) => events._onPointerUp(event),
+    };
+    const input = bindMiniGamePointerEvents(api, runtime.canvas, sink, coordinates);
+    const lifecycle = bindMiniGameLifecycle(api, app.ticker, {
+        onHide: () => input.cancelAll(),
+    });
+    let destroyed = false;
+    const destroy = app.destroy.bind(app);
+    app.destroy = ((...args) => {
+        if (destroyed)
+            return;
+        destroyed = true;
+        lifecycle.dispose();
+        input.dispose();
+        destroy(...args);
+    });
+    return app;
+}

package/dist/platform/minigame/fetch.d.ts

@@ -0,0 +1,2 @@
+import type { MiniGameApi, MiniGameFetch } from './types.js';
+export declare function fetchMiniGameResource(api: MiniGameApi, input: RequestInfo | URL, init: RequestInit | undefined, platformName: string): ReturnType<MiniGameFetch>;