pixifact 0.3.0 → 0.4.0

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;
+}

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

@@ -0,0 +1,105 @@
+export interface WechatCanvas {
+    width: number;
+    height: number;
+    isConnected?: boolean;
+    style?: Record<string, string>;
+    getContext(contextId: string, options?: Record<string, unknown>): unknown;
+    getBoundingClientRect?(): {
+        bottom: number;
+        height: number;
+        left: number;
+        right: number;
+        top: number;
+        width: number;
+        x: number;
+        y: number;
+    };
+    requestAnimationFrame?(callback: FrameRequestCallback): number;
+    cancelAnimationFrame?(requestId: number): void;
+    addEventListener?(type: string, listener: EventListenerOrEventListenerObject, options?: unknown): void;
+    removeEventListener?(type: string, listener: EventListenerOrEventListenerObject, options?: unknown): void;
+    dispatchEvent?(event: Event): boolean;
+}
+export interface WechatImage {
+    width: number;
+    height: number;
+    complete?: boolean;
+    crossOrigin?: string | null;
+    src: string;
+    onload: (() => void) | null;
+    onerror: ((error: unknown) => void) | null;
+}
+export interface WechatTouch {
+    clientX?: number;
+    clientY?: number;
+    force?: number;
+    identifier?: number;
+    pageX?: number;
+    pageY?: number;
+    x?: number;
+    y?: number;
+}
+export interface WechatTouchEvent {
+    changedTouches?: WechatTouch[];
+    touches?: WechatTouch[];
+}
+export interface WechatMiniGameApi {
+    createCanvas(): WechatCanvas;
+    createImage(): WechatImage;
+    createOffscreenCanvas?(options: {
+        type: '2d' | 'webgl';
+        width: number;
+        height: number;
+    }): WechatCanvas;
+    getDeviceInfo?(): Record<string, unknown>;
+    getFileSystemManager(): {
+        readFile(options: {
+            filePath: string;
+            fail(error: {
+                errMsg: string;
+            }): void;
+            success(result: {
+                data: ArrayBuffer | string;
+            }): void;
+        }): void;
+    };
+    getSystemInfoSync?(): Record<string, unknown>;
+    getWindowInfo?(): Record<string, unknown>;
+    loadSubpackage(options: {
+        name: string;
+        fail(error: {
+            errMsg: string;
+        }): void;
+        success(): void;
+    }): {
+        onProgressUpdate(callback: (progress: {
+            progress: number;
+        }) => void): void;
+    };
+    request(options: {
+        url: string;
+        method: 'GET';
+        responseType: 'arraybuffer';
+        fail(error: {
+            errMsg: string;
+        }): void;
+        success(result: {
+            data: ArrayBuffer | string | Record<string, unknown>;
+            header: Record<string, string>;
+            statusCode: number;
+        }): void;
+    }): void;
+    onHide(callback: () => void): void;
+    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;
+}
+export declare function wechatApi(): WechatMiniGameApi;

package/dist/platform/wechat/types.js

@@ -0,0 +1,3 @@
+export function wechatApi() {
+    return globalThis.wx;
+}

package/dist/project/index.d.ts

@@ -10,12 +10,33 @@ 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;
     name: string;
     resolution: PixifactProjectResolution;
     viewport: PixifactProjectViewport;
     scenes: Record<string, string>;
+    resourcePacks?: Record<string, PixifactProjectResourcePack>;
+    targets?: PixifactProjectTargets;
     run?: PixifactProjectRunConfig;
 }
 export type PixifactProjectViewport = PixifactViewportConfig;
@@ -24,6 +45,8 @@ export interface PixifactProjectSummary {
     resolution: PixifactProjectResolution;
     viewport: PixifactProjectViewport;
     scenes: Record<string, string>;
+    resourcePacks?: Record<string, PixifactProjectResourcePack>;
+    targets?: PixifactProjectTargets;
     run?: PixifactProjectRunConfig;
 }
 export declare const defaultPixifactProjectResolution: PixifactProjectResolution;

package/dist/project/index.js

@@ -49,6 +49,13 @@ function normalizeRunCwd(value) {
     }
     return normalizeProjectPath(input, 'run.cwd');
 }
+function normalizeProjectChildPath(value, name) {
+    const input = normalizeProjectPath(value, name);
+    if (input === '.') {
+        throw new Error(`${name} must not be projectRoot.`);
+    }
+    return input;
+}
 function parseScenes(value) {
     const scenes = assertRecord(value, 'scenes');
     return Object.fromEntries(Object.entries(scenes).map(([key, scenePath]) => [
@@ -97,17 +104,77 @@ function parseRun(value) {
         ...(run.url === undefined ? {} : { url: assertString(run.url, 'run.url') }),
     };
 }
+function parseResourcePacks(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const packs = assertRecord(value, 'resourcePacks');
+    return Object.fromEntries(Object.entries(packs).map(([name, packValue]) => {
+        const pack = assertRecord(packValue, `resourcePacks.${name}`);
+        return [assertString(name, 'resource pack name'), {
+                root: normalizeProjectChildPath(pack.root, `resourcePacks.${name}.root`),
+            }];
+    }));
+}
+function parseWechatResourcePacks(value) {
+    const packs = assertRecord(value, 'targets.wechat.resourcePacks');
+    return Object.fromEntries(Object.entries(packs).map(([name, packValue]) => {
+        const pack = assertRecord(packValue, `targets.wechat.resourcePacks.${name}`);
+        const delivery = assertString(pack.delivery, `targets.wechat.resourcePacks.${name}.delivery`);
+        if (delivery === 'subpackage') {
+            return [name, {
+                    delivery,
+                    root: normalizeProjectChildPath(pack.root, `targets.wechat.resourcePacks.${name}.root`),
+                }];
+        }
+        if (delivery === 'remote') {
+            return [name, {
+                    delivery,
+                    baseUrl: assertString(pack.baseUrl, `targets.wechat.resourcePacks.${name}.baseUrl`).replace(/\/+$/, ''),
+                }];
+        }
+        throw new Error(`targets.wechat.resourcePacks.${name}.delivery must be subpackage or remote.`);
+    }));
+}
+function parseTargets(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const targets = assertRecord(value, 'targets');
+    if (targets.wechat === undefined) {
+        return {};
+    }
+    const wechat = assertRecord(targets.wechat, 'targets.wechat');
+    const outDir = normalizeProjectChildPath(wechat.outDir, 'targets.wechat.outDir');
+    return {
+        wechat: {
+            entry: normalizeProjectPath(wechat.entry, 'targets.wechat.entry'),
+            configDir: normalizeProjectPath(wechat.configDir, 'targets.wechat.configDir'),
+            outDir,
+            resourcePacks: parseWechatResourcePacks(wechat.resourcePacks),
+        },
+    };
+}
 export function parsePixifactProjectConfig(value) {
     const config = assertRecord(value, 'pixifact.project.json');
     if (config.version !== 1) {
         throw new Error('pixifact.project.json version must be 1.');
     }
+    const resourcePacks = parseResourcePacks(config.resourcePacks);
+    const targets = parseTargets(config.targets);
+    for (const name of Object.keys(targets?.wechat?.resourcePacks ?? {})) {
+        if (!resourcePacks?.[name]) {
+            throw new Error(`targets.wechat.resourcePacks.${name} must reference resourcePacks.${name}.`);
+        }
+    }
     return {
         version: 1,
         name: assertString(config.name, 'name'),
         resolution: parseResolution(config.resolution),
         viewport: parseViewport(config.viewport),
         scenes: parseScenes(config.scenes),
+        ...(resourcePacks === undefined ? {} : { resourcePacks }),
+        ...(targets === undefined ? {} : { targets }),
         run: parseRun(config.run),
     };
 }
@@ -117,6 +184,8 @@ export function summarizePixifactProjectConfig(config) {
         resolution: config.resolution,
         viewport: config.viewport,
         scenes: config.scenes,
+        ...(config.resourcePacks === undefined ? {} : { resourcePacks: config.resourcePacks }),
+        ...(config.targets === undefined ? {} : { targets: config.targets }),
         ...(config.run === undefined ? {} : { run: config.run }),
     };
 }

package/dist/{compiler → scene}/decorators.d.ts

@@ -1,4 +1,4 @@
-import type { SceneClassDecorator, SceneEventDecoratorOptions, SceneMemberDecorator, ScenePartDecoratorOptions, ScenePropDecoratorOptions, SceneSlotDecoratorOptions } from './spec.js';
+import type { SceneClassDecorator, SceneEventDecoratorOptions, SceneMemberDecorator, ScenePartDecoratorOptions, ScenePropDecoratorOptions, SceneSlotDecoratorOptions } from '../compiler/spec.js';
 export declare function scene(): SceneClassDecorator;
 export declare function prop(options: ScenePropDecoratorOptions): SceneMemberDecorator;
 export declare function event(_options?: SceneEventDecoratorOptions): SceneMemberDecorator;

package/dist/scene/index.d.ts

@@ -0,0 +1,5 @@
+export * from './decorators.js';
+export * from './eventRuntime.js';
+export * from './sceneAssetRuntime.js';
+export * from './sceneRuntime.js';
+export * from './slotRuntime.js';

package/dist/scene/index.js

@@ -0,0 +1,5 @@
+export * from './decorators.js';
+export * from './eventRuntime.js';
+export * from './sceneAssetRuntime.js';
+export * from './sceneRuntime.js';
+export * from './slotRuntime.js';