pixifact 0.6.1 → 0.7.0

package/dist/project/index.js

@@ -49,13 +49,6 @@ 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]) => [
@@ -108,73 +101,66 @@ 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(/\/+$/, ''),
-                }];
+    if (!Array.isArray(value) || !value.every((name) => typeof name === 'string')) {
+        throw new Error('resourcePacks must be an array of strings.');
+    }
+    const packs = value.map((name, index) => {
+        const normalized = normalizeProjectPath(name, `resourcePacks.${index}`);
+        if (normalized.includes('/')) {
+            throw new Error(`resourcePacks.${index} must be a directory name.`);
         }
-        throw new Error(`targets.wechat.resourcePacks.${name}.delivery must be subpackage or remote.`);
-    }));
+        return normalized;
+    });
+    if (new Set(packs).size !== packs.length) {
+        throw new Error('resourcePacks must not contain duplicate names.');
+    }
+    return packs;
 }
-function parseTargets(value) {
+function parseRemoteResourcePacks(value, resourcePacks) {
     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),
-        },
-    };
+    const packs = assertRecord(value, 'remoteResourcePacks');
+    return Object.fromEntries(Object.entries(packs).map(([rawName, rawBaseUrl]) => {
+        const name = assertString(rawName, 'remote resource pack name');
+        if (!resourcePacks?.includes(name)) {
+            throw new Error(`remoteResourcePacks.${name} must reference resourcePacks.`);
+        }
+        const baseUrl = assertString(rawBaseUrl, `remoteResourcePacks.${name}`).replace(/\/+$/, '');
+        let url;
+        try {
+            url = new URL(baseUrl);
+        }
+        catch {
+            throw new Error(`remoteResourcePacks.${name} must be an HTTPS URL.`);
+        }
+        if (url.protocol !== 'https:' || url.hostname === '') {
+            throw new Error(`remoteResourcePacks.${name} must be an HTTPS URL.`);
+        }
+        return [name, baseUrl];
+    }));
 }
 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.');
+    if (config.version !== 2) {
+        throw new Error('pixifact.project.json version must be 2.');
     }
-    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}.`);
-        }
+    if (config.targets !== undefined) {
+        throw new Error('targets is not supported in pixifact.project.json version 2.');
     }
+    if (config.defines !== undefined) {
+        throw new Error('defines is not supported in pixifact.project.json version 2.');
+    }
+    const resourcePacks = parseResourcePacks(config.resourcePacks);
+    const remoteResourcePacks = parseRemoteResourcePacks(config.remoteResourcePacks, resourcePacks);
     return {
-        version: 1,
+        version: 2,
         name: assertString(config.name, 'name'),
         resolution: parseResolution(config.resolution),
         viewport: parseViewport(config.viewport),
         scenes: parseScenes(config.scenes),
         ...(resourcePacks === undefined ? {} : { resourcePacks }),
-        ...(targets === undefined ? {} : { targets }),
+        ...(remoteResourcePacks === undefined ? {} : { remoteResourcePacks }),
         run: parseRun(config.run),
     };
 }
@@ -185,7 +171,7 @@ export function summarizePixifactProjectConfig(config) {
         viewport: config.viewport,
         scenes: config.scenes,
         ...(config.resourcePacks === undefined ? {} : { resourcePacks: config.resourcePacks }),
-        ...(config.targets === undefined ? {} : { targets: config.targets }),
+        ...(config.remoteResourcePacks === undefined ? {} : { remoteResourcePacks: config.remoteResourcePacks }),
         ...(config.run === undefined ? {} : { run: config.run }),
     };
 }

package/dist/scene/index.d.ts

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

package/dist/scene/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pixifact",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Pixifact 2D UI 和轻量游戏 Scene 语义框架。",
   "packageManager": "bun@1.3.13",
   "main": "./dist/index.js",
@@ -26,7 +26,7 @@
   "author": "youxia <243802688@qq.com>",
   "license": "MIT",
   "scripts": {
-    "build": "bun scripts/clean-dist.mjs && bunx --no-install tsc -p tsconfig.build.json && bun scripts/fix-dist-esm-imports.mjs"
+    "build": "bun scripts/clean-dist.mjs && bunx --no-install tsc -p tsconfig.build.json && cp src/client.d.ts dist/client.d.ts && bun scripts/fix-dist-esm-imports.mjs"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -62,14 +62,23 @@
       "import": "./dist/compiler-node/index.js",
       "require": "./dist/compiler-node/index.js"
     },
-    "./platform/wechat": {
-      "types": "./dist/platform/wechat/index.d.ts",
-      "import": "./dist/platform/wechat/index.js",
-      "require": "./dist/platform/wechat/index.js"
+    "./client": {
+      "types": "./dist/client.d.ts"
+    },
+    "./platform/web": {
+      "types": "./dist/platform/web/index.d.ts",
+      "import": "./dist/platform/web/index.js",
+      "require": "./dist/platform/web/index.js"
+    },
+    "./internal/minigame": {
+      "types": "./dist/platform/minigame/index.d.ts",
+      "import": "./dist/platform/minigame/index.js",
+      "require": "./dist/platform/minigame/index.js"
     }
   },
   "peerDependencies": {
-    "pixi.js": ">=8.3.0"
+    "pixi.js": ">=8.3.0",
+    "vite": ">=6.0.0"
   },
   "dependencies": {
     "typescript": "^5.3.3"

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

@@ -1,32 +0,0 @@
-import 'pixi.js/unsafe-eval';
-import 'pixi.js/events';
-import { Container, Rectangle, Ticker, WebGLRenderer, type ColorSource, type EventSystemFeatures } from 'pixi.js';
-import { type WechatPointerBinding } from './input.js';
-import { type WechatLifecycleBinding } from './lifecycle.js';
-import { type WechatRuntime } from './runtime.js';
-import type { WechatCanvas } from './types.js';
-export interface WechatPixiApplicationOptions {
-    antialias?: boolean;
-    autoStart?: boolean;
-    backgroundAlpha?: number;
-    backgroundColor?: ColorSource;
-    eventFeatures?: Partial<EventSystemFeatures>;
-    onHide?(): void;
-    onShow?(): void;
-    resolution?: number;
-}
-export interface WechatPixiApplication {
-    readonly canvas: WechatCanvas;
-    destroy(): void;
-    readonly input: WechatPointerBinding;
-    readonly lifecycle: WechatLifecycleBinding;
-    render(): void;
-    readonly renderer: WebGLRenderer;
-    readonly runtime: WechatRuntime;
-    readonly screen: Rectangle;
-    readonly stage: Container;
-    start(): void;
-    stop(): void;
-    readonly ticker: Ticker;
-}
-export declare function createWechatPixiApplication(options?: WechatPixiApplicationOptions): Promise<WechatPixiApplication>;

package/dist/platform/wechat/application.js

@@ -1,79 +0,0 @@
-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

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

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

@@ -1,4 +0,0 @@
-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

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

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

@@ -1,12 +0,0 @@
-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/lifecycle.d.ts

@@ -1,14 +0,0 @@
-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/subpackage.d.ts

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

package/dist/platform/wechat/subpackage.js

@@ -1,27 +0,0 @@
-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.js

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

package/dist/scene/sceneAssetRuntime.d.ts

@@ -1,11 +0,0 @@
-import { type Texture } from 'pixi.js';
-export interface SceneAssetLocation {
-    src: string;
-    pack?: string;
-}
-export type SceneAssetManifest = Record<string, SceneAssetLocation>;
-export interface SceneAssetRuntimeOptions {
-    loadPack?: (name: string) => Promise<void>;
-}
-export declare function configureSceneAssets(manifest: SceneAssetManifest, options?: SceneAssetRuntimeOptions): void;
-export declare function loadSceneTexture(id: string): Promise<Texture>;

package/dist/scene/sceneAssetRuntime.js

@@ -1,43 +0,0 @@
-import { Assets } from 'pixi.js';
-let assetManifest = {};
-let loadPack;
-const loadedPacks = new Set();
-const loadingPacks = new Map();
-export function configureSceneAssets(manifest, options = {}) {
-    assetManifest = manifest;
-    loadPack = options.loadPack;
-    loadedPacks.clear();
-    loadingPacks.clear();
-}
-async function preparePack(name) {
-    if (loadedPacks.has(name)) {
-        return;
-    }
-    const existing = loadingPacks.get(name);
-    if (existing) {
-        return existing;
-    }
-    if (!loadPack) {
-        throw new Error(`Scene asset pack "${name}" has no platform loader.`);
-    }
-    const pending = loadPack(name).then(() => {
-        loadedPacks.add(name);
-        loadingPacks.delete(name);
-    }, (error) => {
-        loadingPacks.delete(name);
-        throw error;
-    });
-    loadingPacks.set(name, pending);
-    return pending;
-}
-export async function loadSceneTexture(id) {
-    const location = assetManifest[id];
-    if (!location) {
-        throw new Error(`Scene asset "${id}" is missing from the target manifest.`);
-    }
-    if (location.pack) {
-        await preparePack(location.pack);
-    }
-    Assets.add({ alias: id, src: location.src });
-    return Assets.load(id);
-}