pixifact 0.6.0 → 0.7.0

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

@@ -1,5 +1,4 @@
-import { wechatApi } from './types.js';
-class WechatResponseHeaders {
+class MiniGameResponseHeaders {
     values;
     constructor(headers) {
         this.values = new Map(Object.entries(headers).map(([name, value]) => [name.toLowerCase(), String(value)]));
@@ -54,7 +53,7 @@ function encodeUtf8(value) {
     }
     return new Uint8Array(bytes).buffer;
 }
-class WechatResourceResponse {
+class MiniGameResourceResponse {
     responseBody;
     status;
     url;
@@ -70,7 +69,7 @@ class WechatResourceResponse {
         this.status = status;
         this.url = url;
         this.ok = status >= 200 && status < 300;
-        this.headers = new WechatResponseHeaders(responseHeaders);
+        this.headers = new MiniGameResponseHeaders(responseHeaders);
     }
     async arrayBuffer() {
         return typeof this.responseBody === 'string'
@@ -78,16 +77,16 @@ class WechatResourceResponse {
             : this.responseBody.slice(0);
     }
     async blob() {
-        throw new Error('Blob responses are not supported by the WeChat resource adapter.');
+        throw new Error('Blob responses are not supported by the Mini Game resource adapter.');
     }
     clone() {
         const body = typeof this.responseBody === 'string'
             ? this.responseBody
             : this.responseBody.slice(0);
-        return new WechatResourceResponse(body, this.status, this.url);
+        return new MiniGameResourceResponse(body, this.status, this.url);
     }
     async formData() {
-        throw new Error('FormData responses are not supported by the WeChat resource adapter.');
+        throw new Error('FormData responses are not supported by the Mini Game resource adapter.');
     }
     async json() {
         return JSON.parse((await this.text()).replace(/^\uFEFF/, ''));
@@ -114,32 +113,31 @@ function localPath(url) {
     const suffix = url.search(/[?#]/);
     return (suffix >= 0 ? url.slice(0, suffix) : url).replace(/^(\.\/)+/, '');
 }
-export function fetchWechatResource(input, init = {}) {
+export function fetchMiniGameResource(api, input, init = {}, platformName) {
     const method = (init.method ?? 'GET').toUpperCase();
     const url = requestUrl(input);
     if (method !== 'GET') {
-        return Promise.reject(new Error(`The WeChat resource adapter only supports GET requests, received ${method}.`));
+        return Promise.reject(new Error(`The ${platformName} resource adapter only supports GET requests, received ${method}.`));
     }
     if (init.signal?.aborted) {
         return Promise.reject(new Error(`Resource request was aborted: ${url}`));
     }
-    const wx = wechatApi();
     if (/^https?:\/\//i.test(url)) {
-        return new Promise((resolve, reject) => wx.request({
+        return new Promise((resolve, reject) => api.request({
             url,
             method: 'GET',
             responseType: 'arraybuffer',
             fail: (error) => reject(new Error(`Failed to request ${url}: ${error.errMsg}`)),
-            success: (result) => resolve(new WechatResourceResponse(toResponseBody(result.data), result.statusCode, url, result.header)),
+            success: (result) => resolve(new MiniGameResourceResponse(toResponseBody(result.data), result.statusCode, url, result.header)),
         }));
     }
     if (/^data:/i.test(url)) {
-        return Promise.reject(new Error('Data URLs are not supported by the WeChat resource adapter.'));
+        return Promise.reject(new Error(`Data URLs are not supported by the ${platformName} resource adapter.`));
     }
     const filePath = localPath(url);
-    return new Promise((resolve, reject) => wx.getFileSystemManager().readFile({
+    return new Promise((resolve, reject) => api.getFileSystemManager().readFile({
         filePath,
         fail: (error) => reject(new Error(`Failed to read ${filePath}: ${error.errMsg}`)),
-        success: (result) => resolve(new WechatResourceResponse(toResponseBody(result.data), 200, url)),
+        success: (result) => resolve(new MiniGameResourceResponse(toResponseBody(result.data), 200, url)),
     }));
 }

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

@@ -0,0 +1,8 @@
+export * from './adapter.js';
+export * from './application.js';
+export * from './fetch.js';
+export * from './input.js';
+export * from './lifecycle.js';
+export * from './runtime.js';
+export * from './subpackage.js';
+export * from './types.js';

package/dist/platform/minigame/index.js

@@ -0,0 +1,8 @@
+export * from './adapter.js';
+export * from './application.js';
+export * from './fetch.js';
+export * from './input.js';
+export * from './lifecycle.js';
+export * from './runtime.js';
+export * from './subpackage.js';
+export * from './types.js';

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

@@ -0,0 +1,16 @@
+import type { MiniGameApi, MiniGameCanvas, MiniGameTouch } from './types.js';
+export interface MiniGamePointerEventSink {
+    pointerdown(event: Event): void;
+    pointermove(event: Event): void;
+    pointerup(event: Event): void;
+}
+export interface MiniGamePointerBinding {
+    readonly activePointerCount: number;
+    cancelAll(): void;
+    dispose(): void;
+}
+export type MiniGameTouchCoordinates = (touch: MiniGameTouch) => {
+    x: number;
+    y: number;
+};
+export declare function bindMiniGamePointerEvents(api: MiniGameApi, canvas: MiniGameCanvas, sink: MiniGamePointerEventSink, coordinates: MiniGameTouchCoordinates): MiniGamePointerBinding;

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

@@ -1,23 +1,22 @@
-import { WechatPointerEvent } from './runtime.js';
-import { wechatApi } from './types.js';
-function pointerState(touch) {
+import { MiniGamePointerEvent } from './runtime.js';
+function pointerState(touch, coordinates) {
+    const point = coordinates(touch);
     return {
         force: touch.force ?? 0.5,
         pointerId: (touch.identifier ?? 0) + 1,
-        x: touch.clientX ?? touch.x ?? touch.pageX ?? 0,
-        y: touch.clientY ?? touch.y ?? touch.pageY ?? 0,
+        x: point.x,
+        y: point.y,
     };
 }
 function changedTouches(event) {
     return event.changedTouches?.length ? event.changedTouches : event.touches ?? [];
 }
-export function bindWechatPointerEvents(canvas, sink) {
-    const wx = wechatApi();
+export function bindMiniGamePointerEvents(api, canvas, sink, coordinates) {
     const activePointers = new Map();
     let disposed = false;
     let primaryPointerId = null;
     const dispatch = (type, state, eventTarget, buttons) => {
-        const event = new WechatPointerEvent(type, {
+        const event = new MiniGamePointerEvent(type, {
             button: 0,
             buttons,
             clientX: state.x,
@@ -36,7 +35,7 @@ export function bindWechatPointerEvents(canvas, sink) {
     };
     const handleStart = (event) => {
         for (const touch of changedTouches(event)) {
-            const state = pointerState(touch);
+            const state = pointerState(touch, coordinates);
             primaryPointerId ??= state.pointerId;
             activePointers.set(state.pointerId, state);
             dispatch('pointerdown', state, canvas, 1);
@@ -44,14 +43,14 @@ export function bindWechatPointerEvents(canvas, sink) {
     };
     const handleMove = (event) => {
         for (const touch of changedTouches(event)) {
-            const state = pointerState(touch);
+            const state = pointerState(touch, coordinates);
             activePointers.set(state.pointerId, state);
             dispatch('pointermove', state, canvas, 1);
         }
     };
     const release = (event, cancelled) => {
         const touches = event.changedTouches?.length
-            ? event.changedTouches.map(pointerState)
+            ? event.changedTouches.map((touch) => pointerState(touch, coordinates))
             : [...activePointers.values()];
         for (const state of touches) {
             dispatch('pointerup', state, cancelled ? globalThis : canvas, 0);
@@ -63,10 +62,10 @@ export function bindWechatPointerEvents(canvas, sink) {
     };
     const handleEnd = (event) => release(event, false);
     const handleCancel = (event) => release(event, true);
-    wx.onTouchStart(handleStart);
-    wx.onTouchMove(handleMove);
-    wx.onTouchEnd(handleEnd);
-    wx.onTouchCancel(handleCancel);
+    api.onTouchStart(handleStart);
+    api.onTouchMove(handleMove);
+    api.onTouchEnd(handleEnd);
+    api.onTouchCancel(handleCancel);
     return {
         get activePointerCount() {
             return activePointers.size;
@@ -84,10 +83,10 @@ export function bindWechatPointerEvents(canvas, sink) {
             }
             disposed = true;
             this.cancelAll();
-            wx.offTouchStart?.(handleStart);
-            wx.offTouchMove?.(handleMove);
-            wx.offTouchEnd?.(handleEnd);
-            wx.offTouchCancel?.(handleCancel);
+            api.offTouchStart?.(handleStart);
+            api.offTouchMove?.(handleMove);
+            api.offTouchEnd?.(handleEnd);
+            api.offTouchCancel?.(handleCancel);
         },
     };
 }

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

@@ -0,0 +1,15 @@
+import type { MiniGameApi } from './types.js';
+interface LifecycleTarget {
+    readonly started?: boolean;
+    start(): void;
+    stop(): void;
+}
+export interface MiniGameLifecycleBinding {
+    dispose(): void;
+    readonly hidden: boolean;
+}
+export declare function bindMiniGameLifecycle(api: MiniGameApi, target: LifecycleTarget, options?: {
+    onHide?(): void;
+    onShow?(): void;
+}): MiniGameLifecycleBinding;
+export {};

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

@@ -1,6 +1,4 @@
-import { wechatApi } from './types.js';
-export function bindWechatLifecycle(target, options = {}) {
-    const wx = wechatApi();
+export function bindMiniGameLifecycle(api, target, options = {}) {
     let disposed = false;
     let hidden = false;
     let resumeOnShow = false;
@@ -23,8 +21,8 @@ export function bindWechatLifecycle(target, options = {}) {
         }
         options.onShow?.();
     };
-    wx.onHide(handleHide);
-    wx.onShow(handleShow);
+    api.onHide(handleHide);
+    api.onShow(handleShow);
     return {
         dispose() {
             if (disposed) {
@@ -32,8 +30,8 @@ export function bindWechatLifecycle(target, options = {}) {
             }
             disposed = true;
             target.stop();
-            wx.offHide?.(handleHide);
-            wx.offShow?.(handleShow);
+            api.offHide?.(handleHide);
+            api.offShow?.(handleShow);
         },
         get hidden() {
             return hidden;

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

@@ -1,6 +1,6 @@
-import { type WechatCanvas } from './types.js';
-export interface WechatRuntime {
-    canvas: WechatCanvas;
+import type { MiniGameApi, MiniGameCanvas } from './types.js';
+export interface MiniGameRuntime {
+    canvas: MiniGameCanvas;
     context: WebGLRenderingContext | WebGL2RenderingContext;
     height: number;
     resolution: number;
@@ -8,7 +8,7 @@ export interface WechatRuntime {
     webGLVersion: 1 | 2;
     width: number;
 }
-export declare class WechatPointerEvent {
+export declare class MiniGamePointerEvent {
     altKey: boolean;
     bubbles: boolean;
     button: number;
@@ -46,4 +46,4 @@ export declare class WechatPointerEvent {
     stopImmediatePropagation(): void;
     stopPropagation(): void;
 }
-export declare function createWechatRuntime(): WechatRuntime;
+export declare function createMiniGameRuntime(api: MiniGameApi, userAgent: string): MiniGameRuntime;

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

@@ -1,5 +1,4 @@
-import { wechatApi } from './types.js';
-export class WechatPointerEvent {
+export class MiniGamePointerEvent {
     altKey = false;
     bubbles = true;
     button = 0;
@@ -104,10 +103,9 @@ function installCanvasSurface(canvas, width, height) {
         }),
     });
 }
-function createDocumentElement(tagName) {
-    const wx = wechatApi();
+function createDocumentElement(api, tagName) {
     if (tagName.toLowerCase() === 'canvas') {
-        const canvas = wx.createOffscreenCanvas?.({ type: '2d', width: 1, height: 1 }) ?? wx.createCanvas();
+        const canvas = api.createOffscreenCanvas?.({ type: '2d', width: 1, height: 1 }) ?? api.createCanvas();
         canvas.width = 1;
         canvas.height = 1;
         return canvas;
@@ -117,18 +115,18 @@ function createDocumentElement(tagName) {
     }
     return {};
 }
-function installGlobals(canvas, userAgent) {
+function installGlobals(api, canvas, userAgent) {
     const globals = globalThis;
     const mutableGlobals = globals;
     installEventTarget(mutableGlobals);
     const documentTarget = (globals.document ?? {});
     installEventTarget(documentTarget);
-    documentTarget.createElement ??= createDocumentElement;
+    documentTarget.createElement ??= (tagName) => createDocumentElement(api, tagName);
     if (!globals.document) {
         Object.defineProperty(globals, 'document', { configurable: true, value: documentTarget });
     }
     if (!globals.PointerEvent) {
-        Object.defineProperty(globals, 'PointerEvent', { configurable: true, value: WechatPointerEvent });
+        Object.defineProperty(globals, 'PointerEvent', { configurable: true, value: MiniGamePointerEvent });
     }
     if (!globals.navigator) {
         Object.defineProperty(globals, 'navigator', {
@@ -166,24 +164,20 @@ function createContext(canvas) {
     if (webGL1) {
         return { context: webGL1, webGLVersion: 1 };
     }
-    throw new Error('The current WeChat Mini Game runtime does not provide WebGL.');
+    throw new Error('The current Mini Game runtime does not provide WebGL.');
 }
-export function createWechatRuntime() {
-    const wx = wechatApi();
-    const canvas = wx.createCanvas();
+export function createMiniGameRuntime(api, userAgent) {
+    const canvas = api.createCanvas();
     const info = {
-        ...(wx.getSystemInfoSync?.() ?? {}),
-        ...(wx.getDeviceInfo?.() ?? {}),
-        ...(wx.getWindowInfo?.() ?? {}),
+        ...(api.getSystemInfoSync?.() ?? {}),
+        ...(api.getDeviceInfo?.() ?? {}),
+        ...(api.getWindowInfo?.() ?? {}),
     };
     const width = Math.max(1, Math.round(Number(info.windowWidth ?? info.screenWidth)));
     const height = Math.max(1, Math.round(Number(info.windowHeight ?? info.screenHeight)));
-    const resolution = Math.min(2, Math.max(1, Number(info.pixelRatio)));
-    const userAgent = ['WeChatMiniGame', info.platform, info.system, info.model]
-        .filter(Boolean)
-        .join('/');
+    const resolution = Math.min(2, Math.max(1, Number(info.pixelRatio ?? 1)));
     installCanvasSurface(canvas, width, height);
-    installGlobals(canvas, userAgent);
+    installGlobals(api, canvas, userAgent);
     const { context, webGLVersion } = createContext(canvas);
     return { canvas, context, height, resolution, userAgent, webGLVersion, width };
 }

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

@@ -0,0 +1,3 @@
+import type { MiniGameApi } from './types.js';
+export declare function miniGameResourceSubpackage(input: RequestInfo | URL): string | undefined;
+export declare function createMiniGameSubpackageLoader(apiOrFactory: MiniGameApi | (() => MiniGameApi), platformName: string): (name: string) => Promise<void>;

package/dist/platform/minigame/subpackage.js

@@ -0,0 +1,36 @@
+export function miniGameResourceSubpackage(input) {
+    const url = typeof input === 'string' ? input : (input.url ?? String(input));
+    if (/^[a-zA-Z][a-zA-Z\d+.-]*:/.test(url))
+        return undefined;
+    const path = url.replace(/[?#].*$/, '').replace(/^\.?\//, '');
+    return path.match(/^subpackages\/([^/]+)\//)?.[1];
+}
+export function createMiniGameSubpackageLoader(apiOrFactory, platformName) {
+    const getApi = typeof apiOrFactory === 'function' ? apiOrFactory : () => apiOrFactory;
+    const loaded = new Set();
+    const loading = new Map();
+    return function loadSubpackage(name) {
+        if (loaded.has(name)) {
+            return Promise.resolve();
+        }
+        const existing = loading.get(name);
+        if (existing) {
+            return existing;
+        }
+        const pending = new Promise((resolve, reject) => {
+            getApi().loadSubpackage({
+                name,
+                fail: (error) => reject(new Error(`Failed to load ${platformName} subpackage ${name}: ${error.errMsg}`)),
+                success: resolve,
+            });
+        }).then(() => {
+            loaded.add(name);
+            loading.delete(name);
+        }, (error) => {
+            loading.delete(name);
+            throw error;
+        });
+        loading.set(name, pending);
+        return pending;
+    };
+}

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

@@ -1,4 +1,4 @@
-export interface WechatCanvas {
+export interface MiniGameCanvas {
     width: number;
     height: number;
     isConnected?: boolean;
@@ -20,7 +20,7 @@ export interface WechatCanvas {
     removeEventListener?(type: string, listener: EventListenerOrEventListenerObject, options?: unknown): void;
     dispatchEvent?(event: Event): boolean;
 }
-export interface WechatImage {
+export interface MiniGameImage {
     width: number;
     height: number;
     complete?: boolean;
@@ -29,31 +29,34 @@ export interface WechatImage {
     onload: (() => void) | null;
     onerror: ((error: unknown) => void) | null;
 }
-export interface WechatTouch {
+export interface MiniGameTouch {
     clientX?: number;
     clientY?: number;
     force?: number;
     identifier?: number;
     pageX?: number;
     pageY?: number;
+    screenX?: number;
+    screenY?: number;
     x?: number;
     y?: number;
 }
-export interface WechatTouchEvent {
-    changedTouches?: WechatTouch[];
-    touches?: WechatTouch[];
+export interface MiniGameTouchEvent {
+    changedTouches?: MiniGameTouch[];
+    touches?: MiniGameTouch[];
 }
-export interface WechatMiniGameApi {
-    createCanvas(): WechatCanvas;
-    createImage(): WechatImage;
-    createOffscreenCanvas?(options: {
+export interface MiniGameApi {
+    createCanvas(): MiniGameCanvas;
+    createImage(): MiniGameImage;
+    createOffscreenCanvas?(options?: {
         type: '2d' | 'webgl';
         width: number;
         height: number;
-    }): WechatCanvas;
+    }): MiniGameCanvas;
     getDeviceInfo?(): Record<string, unknown>;
     getFileSystemManager(): {
         readFile(options: {
+            encoding?: string;
             filePath: string;
             fail(error: {
                 errMsg: string;
@@ -72,7 +75,7 @@ export interface WechatMiniGameApi {
         }): void;
         success(): void;
     }): {
-        onProgressUpdate(callback: (progress: {
+        onProgressUpdate?(callback: (progress: {
             progress: number;
         }) => void): void;
     };
@@ -93,13 +96,13 @@ export interface WechatMiniGameApi {
     offHide?(callback: () => void): void;
     onShow(callback: () => void): void;
     offShow?(callback: () => void): void;
-    onTouchStart(callback: (event: WechatTouchEvent) => void): void;
-    offTouchStart?(callback: (event: WechatTouchEvent) => void): void;
-    onTouchMove(callback: (event: WechatTouchEvent) => void): void;
-    offTouchMove?(callback: (event: WechatTouchEvent) => void): void;
-    onTouchEnd(callback: (event: WechatTouchEvent) => void): void;
-    offTouchEnd?(callback: (event: WechatTouchEvent) => void): void;
-    onTouchCancel(callback: (event: WechatTouchEvent) => void): void;
-    offTouchCancel?(callback: (event: WechatTouchEvent) => void): void;
+    onTouchStart(callback: (event: MiniGameTouchEvent) => void): void;
+    offTouchStart?(callback: (event: MiniGameTouchEvent) => void): void;
+    onTouchMove(callback: (event: MiniGameTouchEvent) => void): void;
+    offTouchMove?(callback: (event: MiniGameTouchEvent) => void): void;
+    onTouchEnd(callback: (event: MiniGameTouchEvent) => void): void;
+    offTouchEnd?(callback: (event: MiniGameTouchEvent) => void): void;
+    onTouchCancel(callback: (event: MiniGameTouchEvent) => void): void;
+    offTouchCancel?(callback: (event: MiniGameTouchEvent) => void): void;
 }
-export declare function wechatApi(): WechatMiniGameApi;
+export type MiniGameFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;

package/dist/platform/minigame/types.js

@@ -0,0 +1 @@
+export {};

package/dist/platform/web/index.d.ts

@@ -0,0 +1,2 @@
+import { Application, type ApplicationOptions } from 'pixi.js';
+export declare function createApplication(options?: Partial<ApplicationOptions>): Promise<Application>;

package/dist/platform/web/index.js

@@ -0,0 +1,6 @@
+import { Application } from 'pixi.js';
+export async function createApplication(options = {}) {
+    const app = new Application();
+    await app.init(options);
+    return app;
+}

package/dist/project/index.d.ts

@@ -10,33 +10,14 @@ export interface PixifactProjectResolution {
     width: number;
     height: number;
 }
-export interface PixifactProjectResourcePack {
-    root: string;
-}
-export type PixifactWechatResourcePack = {
-    delivery: 'subpackage';
-    root: string;
-} | {
-    delivery: 'remote';
-    baseUrl: string;
-};
-export interface PixifactWechatTargetConfig {
-    entry: string;
-    configDir: string;
-    outDir: string;
-    resourcePacks: Record<string, PixifactWechatResourcePack>;
-}
-export interface PixifactProjectTargets {
-    wechat?: PixifactWechatTargetConfig;
-}
 export interface PixifactProjectConfig {
-    version: 1;
+    version: 2;
     name: string;
     resolution: PixifactProjectResolution;
     viewport: PixifactProjectViewport;
     scenes: Record<string, string>;
-    resourcePacks?: Record<string, PixifactProjectResourcePack>;
-    targets?: PixifactProjectTargets;
+    resourcePacks?: string[];
+    remoteResourcePacks?: Record<string, string>;
     run?: PixifactProjectRunConfig;
 }
 export type PixifactProjectViewport = PixifactViewportConfig;
@@ -45,8 +26,8 @@ export interface PixifactProjectSummary {
     resolution: PixifactProjectResolution;
     viewport: PixifactProjectViewport;
     scenes: Record<string, string>;
-    resourcePacks?: Record<string, PixifactProjectResourcePack>;
-    targets?: PixifactProjectTargets;
+    resourcePacks?: string[];
+    remoteResourcePacks?: Record<string, string>;
     run?: PixifactProjectRunConfig;
 }
 export declare const defaultPixifactProjectResolution: PixifactProjectResolution;