pixifact 0.2.2 → 0.4.0

package/dist/scene/sceneAssetRuntime.d.ts

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

@@ -0,0 +1,43 @@
+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);
+}

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

@@ -2,13 +2,20 @@ import type { Container } from 'pixi.js';
 import type { Group } from '../runtime/index.js';
 export interface SceneMountResult {
     root: Group;
+    nodes: Record<string, Container>;
     parts: Record<string, Container>;
     slots: Record<string, Container>;
 }
 export interface SceneDefinition {
+    assets: string[];
+    dependencies: string[];
     mount(root: Group): SceneMountResult;
+    prepare(): Promise<void>;
 }
 export declare function registerScene(path: string, definition: SceneDefinition): void;
 export declare function registerSceneClass(constructor: object, path: string): void;
 export declare function mountScene(root: Group, path: string): SceneMountResult;
 export declare function mountSceneClass(root: Group, constructor: object): SceneMountResult;
+export declare function prepareScene(path: string): Promise<void>;
+export declare function prepareSceneClass(constructor: object): Promise<void>;
+export declare function getSceneNode(root: Group, locator: string): Container<import("pixi.js").ContainerChild> | undefined;

package/dist/scene/sceneRuntime.js

@@ -0,0 +1,85 @@
+const sceneDefinitions = new Map();
+const scenePathsByConstructor = new WeakMap();
+const sceneMounts = new WeakMap();
+const preparedScenes = new Set();
+const preparingScenes = new Map();
+export function registerScene(path, definition) {
+    sceneDefinitions.set(path, definition);
+    preparedScenes.delete(path);
+    preparingScenes.delete(path);
+}
+export function registerSceneClass(constructor, path) {
+    scenePathsByConstructor.set(constructor, path);
+}
+export function mountScene(root, path) {
+    const definition = sceneDefinitions.get(path);
+    if (!definition) {
+        throw new Error(`Scene "${path}" has not been registered.`);
+    }
+    if (!preparedScenes.has(path)) {
+        throw new Error(`Scene "${path}" must be prepared before it is instantiated.`);
+    }
+    const result = definition.mount(root);
+    sceneMounts.set(root, result);
+    return result;
+}
+export function mountSceneClass(root, constructor) {
+    const path = scenePathsByConstructor.get(constructor);
+    if (!path) {
+        throw new Error(`Scene class "${constructor instanceof Function ? constructor.name : 'unknown'}" has not been bound to a .scene file.`);
+    }
+    return mountScene(root, path);
+}
+export async function prepareScene(path) {
+    if (preparedScenes.has(path)) {
+        return;
+    }
+    assertSceneDependencyGraph(path);
+    const pending = preparingScenes.get(path);
+    if (pending) {
+        return pending;
+    }
+    const definition = sceneDefinitions.get(path);
+    if (!definition) {
+        throw new Error(`Scene "${path}" has not been registered.`);
+    }
+    const preparation = (async () => {
+        await Promise.all(definition.dependencies.map((dependency) => prepareScene(dependency)));
+        await definition.prepare();
+        preparedScenes.add(path);
+        preparingScenes.delete(path);
+    })().catch((error) => {
+        preparingScenes.delete(path);
+        throw error;
+    });
+    preparingScenes.set(path, preparation);
+    return preparation;
+}
+function assertSceneDependencyGraph(path, visiting = new Set(), visited = new Set()) {
+    if (visiting.has(path)) {
+        throw new Error(`Scene dependency cycle detected at "${path}".`);
+    }
+    if (visited.has(path)) {
+        return;
+    }
+    const definition = sceneDefinitions.get(path);
+    if (!definition) {
+        throw new Error(`Scene "${path}" has not been registered.`);
+    }
+    visiting.add(path);
+    for (const dependency of definition.dependencies) {
+        assertSceneDependencyGraph(dependency, visiting, visited);
+    }
+    visiting.delete(path);
+    visited.add(path);
+}
+export async function prepareSceneClass(constructor) {
+    const path = scenePathsByConstructor.get(constructor);
+    if (!path) {
+        throw new Error(`Scene class "${constructor instanceof Function ? constructor.name : 'unknown'}" has not been bound to a .scene file.`);
+    }
+    return prepareScene(path);
+}
+export function getSceneNode(root, locator) {
+    return sceneMounts.get(root)?.nodes[locator];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pixifact",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "Pixifact 2D UI 和轻量游戏 Scene 语义框架。",
   "packageManager": "bun@1.3.13",
   "main": "./dist/index.js",
@@ -42,6 +42,11 @@
       "import": "./dist/runtime/index.js",
       "require": "./dist/runtime/index.js"
     },
+    "./scene": {
+      "types": "./dist/scene/index.d.ts",
+      "import": "./dist/scene/index.js",
+      "require": "./dist/scene/index.js"
+    },
     "./compiler": {
       "types": "./dist/compiler/index.d.ts",
       "import": "./dist/compiler/index.js",
@@ -51,6 +56,11 @@
       "types": "./dist/compiler-node/index.d.ts",
       "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"
     }
   },
   "peerDependencies": {

package/dist/compiler/sceneRuntime.js

@@ -1,22 +0,0 @@
-const sceneDefinitions = new Map();
-const scenePathsByConstructor = new WeakMap();
-export function registerScene(path, definition) {
-    sceneDefinitions.set(path, definition);
-}
-export function registerSceneClass(constructor, path) {
-    scenePathsByConstructor.set(constructor, path);
-}
-export function mountScene(root, path) {
-    const definition = sceneDefinitions.get(path);
-    if (!definition) {
-        throw new Error(`Scene "${path}" has not been registered.`);
-    }
-    return definition.mount(root);
-}
-export function mountSceneClass(root, constructor) {
-    const path = scenePathsByConstructor.get(constructor);
-    if (!path) {
-        throw new Error(`Scene class "${constructor instanceof Function ? constructor.name : 'unknown'}" has not been bound to a .scene file.`);
-    }
-    return mountScene(root, path);
-}