pixifact 0.3.0 → 0.5.0

package/dist/platform/wechat/application.js

@@ -0,0 +1,79 @@
+import 'pixi.js/unsafe-eval';
+import 'pixi.js/events';
+import { Container, DOMAdapter, loadTextures, Rectangle, Ticker, UPDATE_PRIORITY, WebGLRenderer, } from 'pixi.js';
+import { createWechatPixiAdapter } from './adapter.js';
+import { bindWechatPointerEvents } from './input.js';
+import { bindWechatLifecycle } from './lifecycle.js';
+import { createWechatRuntime } from './runtime.js';
+export async function createWechatPixiApplication(options = {}) {
+    const runtime = createWechatRuntime();
+    DOMAdapter.set(createWechatPixiAdapter(runtime));
+    loadTextures.config.preferCreateImageBitmap = false;
+    const renderer = new WebGLRenderer();
+    await renderer.init({
+        antialias: options.antialias ?? true,
+        autoDensity: false,
+        backgroundAlpha: options.backgroundAlpha ?? 1,
+        backgroundColor: options.backgroundColor ?? 0x000000,
+        canvas: runtime.canvas,
+        context: runtime.context,
+        eventFeatures: options.eventFeatures ?? {
+            click: true,
+            globalMove: true,
+            move: true,
+            wheel: false,
+        },
+        height: runtime.height,
+        resolution: options.resolution ?? runtime.resolution,
+        skipExtensionImports: true,
+        width: runtime.width,
+    });
+    const stage = new Container();
+    const screen = new Rectangle(0, 0, runtime.width, runtime.height);
+    const ticker = new Ticker();
+    const render = () => renderer.render(stage);
+    const events = renderer.events;
+    const sink = {
+        pointerdown: (event) => events._onPointerDown(event),
+        pointermove: (event) => events._onPointerMove(event),
+        pointerup: (event) => events._onPointerUp(event),
+    };
+    const input = bindWechatPointerEvents(runtime.canvas, sink);
+    const lifecycle = bindWechatLifecycle(ticker, {
+        onHide: () => {
+            input.cancelAll();
+            options.onHide?.();
+        },
+        onShow: options.onShow,
+    });
+    let destroyed = false;
+    ticker.add(render, undefined, UPDATE_PRIORITY.LOW);
+    render();
+    if (options.autoStart !== false) {
+        ticker.start();
+    }
+    return {
+        canvas: runtime.canvas,
+        destroy() {
+            if (destroyed) {
+                return;
+            }
+            destroyed = true;
+            lifecycle.dispose();
+            input.dispose();
+            ticker.destroy();
+            stage.destroy({ children: true });
+            renderer.destroy();
+        },
+        input,
+        lifecycle,
+        render,
+        renderer,
+        runtime,
+        screen,
+        stage,
+        start: () => ticker.start(),
+        stop: () => ticker.stop(),
+        ticker,
+    };
+}

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

@@ -0,0 +1 @@
+export declare function fetchWechatResource(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;

package/dist/platform/wechat/fetch.js

@@ -0,0 +1,145 @@
+import { wechatApi } from './types.js';
+class WechatResponseHeaders {
+    values;
+    constructor(headers) {
+        this.values = new Map(Object.entries(headers).map(([name, value]) => [name.toLowerCase(), String(value)]));
+    }
+    get(name) {
+        return this.values.get(name.toLowerCase()) ?? null;
+    }
+}
+function decodeUtf8(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let output = '';
+    for (let index = 0; index < bytes.length;) {
+        const first = bytes[index++];
+        let codePoint;
+        if (first < 0x80) {
+            codePoint = first;
+        }
+        else if (first < 0xe0) {
+            codePoint = ((first & 0x1f) << 6) | (bytes[index++] & 0x3f);
+        }
+        else if (first < 0xf0) {
+            codePoint = ((first & 0x0f) << 12)
+                | ((bytes[index++] & 0x3f) << 6)
+                | (bytes[index++] & 0x3f);
+        }
+        else {
+            codePoint = ((first & 0x07) << 18)
+                | ((bytes[index++] & 0x3f) << 12)
+                | ((bytes[index++] & 0x3f) << 6)
+                | (bytes[index++] & 0x3f);
+        }
+        output += String.fromCodePoint(codePoint);
+    }
+    return output;
+}
+function encodeUtf8(value) {
+    const bytes = [];
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (codePoint < 0x80) {
+            bytes.push(codePoint);
+        }
+        else if (codePoint < 0x800) {
+            bytes.push(0xc0 | (codePoint >> 6), 0x80 | (codePoint & 0x3f));
+        }
+        else if (codePoint < 0x10000) {
+            bytes.push(0xe0 | (codePoint >> 12), 0x80 | ((codePoint >> 6) & 0x3f), 0x80 | (codePoint & 0x3f));
+        }
+        else {
+            bytes.push(0xf0 | (codePoint >> 18), 0x80 | ((codePoint >> 12) & 0x3f), 0x80 | ((codePoint >> 6) & 0x3f), 0x80 | (codePoint & 0x3f));
+        }
+    }
+    return new Uint8Array(bytes).buffer;
+}
+class WechatResourceResponse {
+    responseBody;
+    status;
+    url;
+    body = null;
+    bodyUsed = false;
+    ok;
+    redirected = false;
+    statusText = '';
+    type = 'basic';
+    headers;
+    constructor(responseBody, status, url, responseHeaders = {}) {
+        this.responseBody = responseBody;
+        this.status = status;
+        this.url = url;
+        this.ok = status >= 200 && status < 300;
+        this.headers = new WechatResponseHeaders(responseHeaders);
+    }
+    async arrayBuffer() {
+        return typeof this.responseBody === 'string'
+            ? encodeUtf8(this.responseBody)
+            : this.responseBody.slice(0);
+    }
+    async blob() {
+        throw new Error('Blob responses are not supported by the WeChat resource adapter.');
+    }
+    clone() {
+        const body = typeof this.responseBody === 'string'
+            ? this.responseBody
+            : this.responseBody.slice(0);
+        return new WechatResourceResponse(body, this.status, this.url);
+    }
+    async formData() {
+        throw new Error('FormData responses are not supported by the WeChat resource adapter.');
+    }
+    async json() {
+        return JSON.parse((await this.text()).replace(/^\uFEFF/, ''));
+    }
+    async text() {
+        return typeof this.responseBody === 'string'
+            ? this.responseBody
+            : decodeUtf8(this.responseBody);
+    }
+}
+function toResponseBody(data) {
+    if (data instanceof ArrayBuffer) {
+        return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+        return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    }
+    return typeof data === 'string' ? data : JSON.stringify(data);
+}
+function requestUrl(input) {
+    return typeof input === 'string' ? input : (input.url ?? String(input));
+}
+function localPath(url) {
+    const suffix = url.search(/[?#]/);
+    return (suffix >= 0 ? url.slice(0, suffix) : url).replace(/^(\.\/)+/, '');
+}
+export function fetchWechatResource(input, init = {}) {
+    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}.`));
+    }
+    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({
+            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)),
+        }));
+    }
+    if (/^data:/i.test(url)) {
+        return Promise.reject(new Error('Data URLs are not supported by the WeChat resource adapter.'));
+    }
+    const filePath = localPath(url);
+    return new Promise((resolve, reject) => wx.getFileSystemManager().readFile({
+        filePath,
+        fail: (error) => reject(new Error(`Failed to read ${filePath}: ${error.errMsg}`)),
+        success: (result) => resolve(new WechatResourceResponse(toResponseBody(result.data), 200, url)),
+    }));
+}

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

@@ -0,0 +1,4 @@
+export * from './application.js';
+export * from './fetch.js';
+export * from './subpackage.js';
+export type { WechatCanvas, WechatMiniGameApi } from './types.js';

package/dist/platform/wechat/index.js

@@ -0,0 +1,3 @@
+export * from './application.js';
+export * from './fetch.js';
+export * from './subpackage.js';

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

@@ -0,0 +1,12 @@
+import { type WechatCanvas } from './types.js';
+export interface WechatPointerEventSink {
+    pointerdown(event: Event): void;
+    pointermove(event: Event): void;
+    pointerup(event: Event): void;
+}
+export interface WechatPointerBinding {
+    readonly activePointerCount: number;
+    cancelAll(): void;
+    dispose(): void;
+}
+export declare function bindWechatPointerEvents(canvas: WechatCanvas, sink: WechatPointerEventSink): WechatPointerBinding;

package/dist/platform/wechat/input.js

@@ -0,0 +1,93 @@
+import { WechatPointerEvent } from './runtime.js';
+import { wechatApi } from './types.js';
+function pointerState(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,
+    };
+}
+function changedTouches(event) {
+    return event.changedTouches?.length ? event.changedTouches : event.touches ?? [];
+}
+export function bindWechatPointerEvents(canvas, sink) {
+    const wx = wechatApi();
+    const activePointers = new Map();
+    let disposed = false;
+    let primaryPointerId = null;
+    const dispatch = (type, state, eventTarget, buttons) => {
+        const event = new WechatPointerEvent(type, {
+            button: 0,
+            buttons,
+            clientX: state.x,
+            clientY: state.y,
+            height: 1,
+            isPrimary: state.pointerId === primaryPointerId,
+            pointerId: state.pointerId,
+            pointerType: 'touch',
+            pressure: buttons ? state.force : 0,
+            width: 1,
+        });
+        event.target = eventTarget;
+        event.srcElement = canvas;
+        event.isTrusted = true;
+        sink[type](event);
+    };
+    const handleStart = (event) => {
+        for (const touch of changedTouches(event)) {
+            const state = pointerState(touch);
+            primaryPointerId ??= state.pointerId;
+            activePointers.set(state.pointerId, state);
+            dispatch('pointerdown', state, canvas, 1);
+        }
+    };
+    const handleMove = (event) => {
+        for (const touch of changedTouches(event)) {
+            const state = pointerState(touch);
+            activePointers.set(state.pointerId, state);
+            dispatch('pointermove', state, canvas, 1);
+        }
+    };
+    const release = (event, cancelled) => {
+        const touches = event.changedTouches?.length
+            ? event.changedTouches.map(pointerState)
+            : [...activePointers.values()];
+        for (const state of touches) {
+            dispatch('pointerup', state, cancelled ? globalThis : canvas, 0);
+            activePointers.delete(state.pointerId);
+        }
+        if (primaryPointerId !== null && !activePointers.has(primaryPointerId)) {
+            primaryPointerId = activePointers.keys().next().value ?? null;
+        }
+    };
+    const handleEnd = (event) => release(event, false);
+    const handleCancel = (event) => release(event, true);
+    wx.onTouchStart(handleStart);
+    wx.onTouchMove(handleMove);
+    wx.onTouchEnd(handleEnd);
+    wx.onTouchCancel(handleCancel);
+    return {
+        get activePointerCount() {
+            return activePointers.size;
+        },
+        cancelAll() {
+            for (const state of activePointers.values()) {
+                dispatch('pointerup', state, globalThis, 0);
+            }
+            activePointers.clear();
+            primaryPointerId = null;
+        },
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            this.cancelAll();
+            wx.offTouchStart?.(handleStart);
+            wx.offTouchMove?.(handleMove);
+            wx.offTouchEnd?.(handleEnd);
+            wx.offTouchCancel?.(handleCancel);
+        },
+    };
+}

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

@@ -0,0 +1,14 @@
+interface LifecycleTarget {
+    readonly started?: boolean;
+    start(): void;
+    stop(): void;
+}
+export interface WechatLifecycleBinding {
+    dispose(): void;
+    readonly hidden: boolean;
+}
+export declare function bindWechatLifecycle(target: LifecycleTarget, options?: {
+    onHide?(): void;
+    onShow?(): void;
+}): WechatLifecycleBinding;
+export {};

package/dist/platform/wechat/lifecycle.js

@@ -0,0 +1,42 @@
+import { wechatApi } from './types.js';
+export function bindWechatLifecycle(target, options = {}) {
+    const wx = wechatApi();
+    let disposed = false;
+    let hidden = false;
+    let resumeOnShow = false;
+    const handleHide = () => {
+        if (disposed || hidden) {
+            return;
+        }
+        hidden = true;
+        resumeOnShow = target.started ?? true;
+        options.onHide?.();
+        target.stop();
+    };
+    const handleShow = () => {
+        if (disposed || !hidden) {
+            return;
+        }
+        hidden = false;
+        if (resumeOnShow) {
+            target.start();
+        }
+        options.onShow?.();
+    };
+    wx.onHide(handleHide);
+    wx.onShow(handleShow);
+    return {
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            target.stop();
+            wx.offHide?.(handleHide);
+            wx.offShow?.(handleShow);
+        },
+        get hidden() {
+            return hidden;
+        },
+    };
+}

package/dist/platform/wechat/runtime.d.ts

@@ -0,0 +1,49 @@
+import { type WechatCanvas } from './types.js';
+export interface WechatRuntime {
+    canvas: WechatCanvas;
+    context: WebGLRenderingContext | WebGL2RenderingContext;
+    height: number;
+    resolution: number;
+    userAgent: string;
+    webGLVersion: 1 | 2;
+    width: number;
+}
+export declare class WechatPointerEvent {
+    altKey: boolean;
+    bubbles: boolean;
+    button: number;
+    buttons: number;
+    cancelBubble: boolean;
+    cancelable: boolean;
+    clientX: number;
+    clientY: number;
+    ctrlKey: boolean;
+    defaultPrevented: boolean;
+    height: number;
+    isPrimary: boolean;
+    isTrusted: boolean;
+    metaKey: boolean;
+    movementX: number;
+    movementY: number;
+    pageX: number;
+    pageY: number;
+    pointerId: number;
+    pointerType: string;
+    pressure: number;
+    relatedTarget: EventTarget | null;
+    shiftKey: boolean;
+    srcElement: EventTarget | null;
+    tangentialPressure: number;
+    target: EventTarget | null;
+    tiltX: number;
+    tiltY: number;
+    twist: number;
+    type: string;
+    width: number;
+    constructor(type: string, init?: PointerEventInit);
+    composedPath(): EventTarget[];
+    preventDefault(): void;
+    stopImmediatePropagation(): void;
+    stopPropagation(): void;
+}
+export declare function createWechatRuntime(): WechatRuntime;

package/dist/platform/wechat/runtime.js

@@ -0,0 +1,189 @@
+import { wechatApi } from './types.js';
+export class WechatPointerEvent {
+    altKey = false;
+    bubbles = true;
+    button = 0;
+    buttons = 0;
+    cancelBubble = false;
+    cancelable = true;
+    clientX = 0;
+    clientY = 0;
+    ctrlKey = false;
+    defaultPrevented = false;
+    height = 1;
+    isPrimary = false;
+    isTrusted = false;
+    metaKey = false;
+    movementX = 0;
+    movementY = 0;
+    pageX = 0;
+    pageY = 0;
+    pointerId = 0;
+    pointerType = '';
+    pressure = 0;
+    relatedTarget = null;
+    shiftKey = false;
+    srcElement = null;
+    tangentialPressure = 0;
+    target = null;
+    tiltX = 0;
+    tiltY = 0;
+    twist = 0;
+    type;
+    width = 1;
+    constructor(type, init = {}) {
+        this.type = type;
+        Object.assign(this, init);
+        this.pageX = this.clientX;
+        this.pageY = this.clientY;
+    }
+    composedPath() {
+        return this.target ? [this.target] : [];
+    }
+    preventDefault() {
+        this.defaultPrevented = true;
+    }
+    stopImmediatePropagation() {
+        this.cancelBubble = true;
+    }
+    stopPropagation() {
+        this.cancelBubble = true;
+    }
+}
+function installEventTarget(target, nativeTypes = new Set()) {
+    const listeners = new Map();
+    const nativeAdd = target.addEventListener?.bind(target);
+    const nativeRemove = target.removeEventListener?.bind(target);
+    target.addEventListener = (type, listener, options) => {
+        const typeListeners = listeners.get(type) ?? new Set();
+        typeListeners.add(listener);
+        listeners.set(type, typeListeners);
+        if (nativeTypes.has(type)) {
+            nativeAdd?.(type, listener, options);
+        }
+    };
+    target.removeEventListener = (type, listener, options) => {
+        listeners.get(type)?.delete(listener);
+        if (nativeTypes.has(type)) {
+            nativeRemove?.(type, listener, options);
+        }
+    };
+    target.dispatchEvent = (event) => {
+        const mutableEvent = event;
+        mutableEvent.target ??= target;
+        mutableEvent.srcElement ??= mutableEvent.target;
+        for (const listener of listeners.get(event.type) ?? []) {
+            if (typeof listener === 'function') {
+                listener.call(target, event);
+            }
+            else {
+                listener.handleEvent(event);
+            }
+            if (mutableEvent.cancelBubble) {
+                break;
+            }
+        }
+        return !event.defaultPrevented;
+    };
+}
+function installCanvasSurface(canvas, width, height) {
+    installEventTarget(canvas, new Set(['webglcontextlost', 'webglcontextrestored']));
+    canvas.style ??= {};
+    Object.defineProperty(canvas, 'isConnected', { configurable: true, value: true });
+    Object.defineProperty(canvas, 'getBoundingClientRect', {
+        configurable: true,
+        value: () => ({
+            bottom: height,
+            height,
+            left: 0,
+            right: width,
+            top: 0,
+            width,
+            x: 0,
+            y: 0,
+        }),
+    });
+}
+function createDocumentElement(tagName) {
+    const wx = wechatApi();
+    if (tagName.toLowerCase() === 'canvas') {
+        const canvas = wx.createOffscreenCanvas?.({ type: '2d', width: 1, height: 1 }) ?? wx.createCanvas();
+        canvas.width = 1;
+        canvas.height = 1;
+        return canvas;
+    }
+    if (tagName.toLowerCase() === 'video') {
+        return { canPlayType: () => '' };
+    }
+    return {};
+}
+function installGlobals(canvas, userAgent) {
+    const globals = globalThis;
+    const mutableGlobals = globals;
+    installEventTarget(mutableGlobals);
+    const documentTarget = (globals.document ?? {});
+    installEventTarget(documentTarget);
+    documentTarget.createElement ??= createDocumentElement;
+    if (!globals.document) {
+        Object.defineProperty(globals, 'document', { configurable: true, value: documentTarget });
+    }
+    if (!globals.PointerEvent) {
+        Object.defineProperty(globals, 'PointerEvent', { configurable: true, value: WechatPointerEvent });
+    }
+    if (!globals.navigator) {
+        Object.defineProperty(globals, 'navigator', {
+            configurable: true,
+            value: { gpu: null, userAgent },
+        });
+    }
+    if (!globals.performance) {
+        Object.defineProperty(globals, 'performance', {
+            configurable: true,
+            value: { now: () => Date.now() },
+        });
+    }
+    globals.requestAnimationFrame ??= canvas.requestAnimationFrame
+        ? canvas.requestAnimationFrame.bind(canvas)
+        : (callback) => setTimeout(() => callback(performance.now()), 16);
+    globals.cancelAnimationFrame ??= canvas.cancelAnimationFrame
+        ? canvas.cancelAnimationFrame.bind(canvas)
+        : (requestId) => clearTimeout(requestId);
+}
+function createContext(canvas) {
+    const attributes = {
+        alpha: false,
+        antialias: true,
+        powerPreference: 'high-performance',
+        premultipliedAlpha: true,
+        preserveDrawingBuffer: false,
+        stencil: true,
+    };
+    const webGL2 = canvas.getContext('webgl2', attributes);
+    if (webGL2) {
+        return { context: webGL2, webGLVersion: 2 };
+    }
+    const webGL1 = canvas.getContext('webgl', attributes);
+    if (webGL1) {
+        return { context: webGL1, webGLVersion: 1 };
+    }
+    throw new Error('The current WeChat Mini Game runtime does not provide WebGL.');
+}
+export function createWechatRuntime() {
+    const wx = wechatApi();
+    const canvas = wx.createCanvas();
+    const info = {
+        ...(wx.getSystemInfoSync?.() ?? {}),
+        ...(wx.getDeviceInfo?.() ?? {}),
+        ...(wx.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('/');
+    installCanvasSurface(canvas, width, height);
+    installGlobals(canvas, userAgent);
+    const { context, webGLVersion } = createContext(canvas);
+    return { canvas, context, height, resolution, userAgent, webGLVersion, width };
+}

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

@@ -0,0 +1 @@
+export declare function loadWechatSubpackage(name: string): Promise<void>;

package/dist/platform/wechat/subpackage.js

@@ -0,0 +1,27 @@
+import { wechatApi } from './types.js';
+const loaded = new Set();
+const loading = new Map();
+export function loadWechatSubpackage(name) {
+    if (loaded.has(name)) {
+        return Promise.resolve();
+    }
+    const existing = loading.get(name);
+    if (existing) {
+        return existing;
+    }
+    const pending = new Promise((resolve, reject) => {
+        wechatApi().loadSubpackage({
+            name,
+            fail: (error) => reject(new Error(`Failed to load WeChat 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;
+}