pixifact 0.1.3 → 0.1.4

package/dist/runtime/Transform.js

@@ -1,157 +0,0 @@
-import { Vector2 } from '@math.gl/core';
-import { GameObjectEvent } from './GameObjectEvent.js';
-export class Transform {
-    gameObject;
-    // x: number;
-    // y: number;
-    // width: number;
-    // height: number;
-    // scaleX: number;
-    // scaleY: number;
-    constructor(gameObject) {
-        this.gameObject = gameObject;
-    }
-    _position = new Vector2(0, 0);
-    get position() {
-        return this._position;
-    }
-    set position(val) {
-        this.setPosition(val.x, val.y);
-    }
-    get x() {
-        return this.position.x;
-    }
-    set x(val) {
-        this.setPosition(val, this.position.y);
-    }
-    get y() {
-        return this.position.y;
-    }
-    set y(val) {
-        this.setPosition(this.position.x, val);
-    }
-    setPosition(x, y) {
-        const displayPosition = this.gameObject.display?.position;
-        const isPositionChanged = this.position.x !== x || this.position.y !== y;
-        const isDisplayPositionChanged = displayPosition
-            ? displayPosition.x !== x || displayPosition.y !== y
-            : false;
-        if (!isPositionChanged && !isDisplayPositionChanged) {
-            return;
-        }
-        this.position.set(x, y);
-        if (displayPosition) {
-            displayPosition.set(x, y);
-        }
-        this.emitTransformChange();
-        this.gameObject.emitter.emit(GameObjectEvent.REPOSITION);
-    }
-    emitTransformChange() {
-        this.gameObject.emitter.emit(GameObjectEvent.TRANSFORM_CHANGE);
-    }
-    // private _size = new Vector2();
-    // get size() {
-    //     return this._size;
-    // }
-    // set size(val: Vector2) {
-    //     this.width = val.x;
-    //     this.height = val.y;
-    // }
-    // get width() {
-    //     return this.size.x;
-    // }
-    // set width(val: number) {
-    //     this.size.x = val;
-    //     // this.gameObject.display.scale.x = this.scale.x;
-    //     // this.gameObject.display.width = this.size.x;
-    //     // this.gameObject.display.scale.x = this.scale.x;
-    // }
-    // get height() {
-    //     return this.size.y;
-    // }
-    // set height(val: number) {
-    //     this.size.y = val;
-    //     this.gameObject.display.height = this.size.y * this.scale.y;
-    // }
-    _scale = new Vector2(1, 1);
-    get scale() {
-        return this._scale;
-    }
-    set scale(val) {
-        this.scaleX = val.x;
-        this.scaleY = val.y;
-    }
-    get scaleX() {
-        return this.scale.x;
-    }
-    set scaleX(val) {
-        if (this.scale.x === val && this.gameObject.display.scale.x === val) {
-            return;
-        }
-        this.scale.x = val;
-        this.gameObject.display.scale.x = this.scale.x;
-        this.emitTransformChange();
-    }
-    get scaleY() {
-        return this.scale.y;
-    }
-    set scaleY(val) {
-        if (this.scale.y === val && this.gameObject.display.scale.y === val) {
-            return;
-        }
-        this.scale.y = val;
-        this.gameObject.display.scale.y = this.scale.y;
-        this.emitTransformChange();
-    }
-    get pivotX() {
-        return this.gameObject.display.pivot.x;
-    }
-    set pivotX(val) {
-        if (this.gameObject.display.pivot.x === val) {
-            return;
-        }
-        this.gameObject.display.pivot.x = val;
-        this.emitTransformChange();
-    }
-    get pivotY() {
-        return this.gameObject.display.pivot.y;
-    }
-    set pivotY(val) {
-        if (this.gameObject.display.pivot.y === val) {
-            return;
-        }
-        this.gameObject.display.pivot.y = val;
-        this.emitTransformChange();
-    }
-    // this.label.display.transform.pivot.set(-50, 0);
-    get rotation() {
-        return this.gameObject.display.rotation;
-    }
-    set rotation(val) {
-        if (this.gameObject.display.rotation === val) {
-            return;
-        }
-        this.gameObject.display.rotation = val;
-        this.emitTransformChange();
-    }
-    get skewX() {
-        return this.gameObject.display.skew.x;
-    }
-    set skewX(val) {
-        if (this.gameObject.display.skew.x === val) {
-            return;
-        }
-        this.gameObject.display.skew.x = val;
-        this.emitTransformChange();
-    }
-    get skewY() {
-        return this.gameObject.display.skew.y;
-    }
-    set skewY(val) {
-        if (this.gameObject.display.skew.y === val) {
-            return;
-        }
-        this.gameObject.display.skew.y = val;
-        this.emitTransformChange();
-    }
-}

package/dist/runtime/component/Component.d.ts

@@ -1,13 +0,0 @@
-import { GameObject } from "../GameObject.js";
-export declare abstract class Component<T extends GameObject = GameObject> {
-    gameObject: T;
-    constructor(gameObject: T);
-    awake?(): void;
-    start?(): void;
-    update?(_dt: number): void;
-    /**
-     * 销毁组件
-     */
-    destroy(): void;
-    onDestroy?(): void;
-}

package/dist/runtime/component/Component.js

@@ -1,13 +0,0 @@
-export class Component {
-    gameObject;
-    constructor(gameObject) {
-        this.gameObject = gameObject;
-        gameObject.display.on('destroyed', this.destroy, this);
-    }
-    /**
-     * 销毁组件
-     */
-    destroy() {
-        this.gameObject.removeComponent(this);
-    }
-}

package/dist/runtime/component/ComponentRegistry.d.ts

@@ -1,49 +0,0 @@
-import type { Component } from "./Component.js";
-export type ComponentConstructor<T extends Component = Component> = new (...args: any[]) => T;
-export type PropFieldType = 'number' | 'string' | 'boolean' | 'color' | 'enum' | 'vec2' | 'rect' | 'assetRef' | 'nodeRef' | 'componentRef' | 'event';
-export interface PropSchema {
-    key: string;
-    type: PropFieldType;
-    default?: unknown;
-    description?: string;
-    min?: number;
-    max?: number;
-    options?: readonly (string | number)[];
-    component?: string;
-    assetType?: string;
-    hidden?: boolean;
-    readOnly?: boolean;
-    serialize?: boolean;
-    examples?: readonly unknown[];
-}
-export interface ComponentSchema<T extends Component = Component> {
-    type: string;
-    ctor: ComponentConstructor<T>;
-    displayName?: string;
-    category?: string;
-    icon?: string;
-    description?: string;
-    disallowMultiple?: boolean;
-    require?: readonly string[];
-    props: readonly PropSchema[];
-}
-export interface ComponentMetaOptions {
-    type: string;
-    displayName?: string;
-    category?: string;
-    icon?: string;
-    description?: string;
-    disallowMultiple?: boolean;
-    require?: readonly string[];
-}
-export interface PropOptions extends Omit<PropSchema, 'key'> {
-}
-export declare class ComponentRegistry {
-    private static schemasByType;
-    private static schemasByCtor;
-    static register<T extends Component>(schema: ComponentSchema<T>): ComponentSchema<T>;
-    static get<T extends Component = Component>(type: string): ComponentSchema<T> | undefined;
-    static getByCtor<T extends Component = Component>(ctor: ComponentConstructor<T>): ComponentSchema<T> | undefined;
-    static list(): ComponentSchema<Component<import("..").GameObject<import("pixi.js").Container<import("pixi.js").ContainerChild>>>>[];
-    static clear(): void;
-}

package/dist/runtime/component/ComponentRegistry.js

@@ -1,25 +0,0 @@
-export class ComponentRegistry {
-    static schemasByType = new Map();
-    static schemasByCtor = new Map();
-    static register(schema) {
-        if (this.schemasByType.has(schema.type)) {
-            throw new Error(`Component type "${schema.type}" is already registered.`);
-        }
-        this.schemasByType.set(schema.type, schema);
-        this.schemasByCtor.set(schema.ctor, schema);
-        return schema;
-    }
-    static get(type) {
-        return this.schemasByType.get(type);
-    }
-    static getByCtor(ctor) {
-        return this.schemasByCtor.get(ctor);
-    }
-    static list() {
-        return Array.from(this.schemasByType.values());
-    }
-    static clear() {
-        this.schemasByType.clear();
-        this.schemasByCtor.clear();
-    }
-}

package/dist/runtime/component/Flex.d.ts

@@ -1,6 +0,0 @@
-import { Component } from "./Component.js";
-export declare class Flex extends Component {
-    private _grow;
-    get grow(): number;
-    set grow(val: number);
-}

package/dist/runtime/component/Flex.js

@@ -1,15 +0,0 @@
-import { Component } from "./Component.js";
-import { GameObject } from "../GameObject.js";
-export class Flex extends Component {
-    _grow = 1;
-    get grow() {
-        return this._grow;
-    }
-    set grow(val) {
-        if (this._grow === val) {
-            return;
-        }
-        this._grow = val;
-        this.gameObject.parent?.emitter.emit(GameObject.Event.RESIZE);
-    }
-}

package/dist/runtime/component/FlexGroup.d.ts

@@ -1,26 +0,0 @@
-import { Group } from "../group/index.js";
-import { Component } from "./Component.js";
-export declare enum FlexDirection {
-    ROW = 0,
-    COLUMN = 1
-}
-export declare class FlexGroup extends Component<Group> {
-    private _active;
-    private _applyingLayout;
-    private _direction;
-    get direction(): FlexDirection;
-    set direction(val: FlexDirection);
-    private _gap;
-    get gap(): number;
-    set gap(val: number);
-    awake(): void;
-    private handleResize;
-    private handleChildAdded;
-    private handleChildRemoved;
-    private handleChildResize;
-    private bindChild;
-    private unbindChild;
-    private markResize;
-    resize: () => void;
-    onDestroy(): void;
-}

package/dist/runtime/component/FlexGroup.js

@@ -1,136 +0,0 @@
-import { GameObject } from "../GameObject.js";
-import { onlyOnceQueueMicrotask } from "../utils/onlyOnceQueueMicrotask.js";
-import { Component } from "./Component.js";
-import { Flex } from "./Flex.js";
-export var FlexDirection;
-(function (FlexDirection) {
-    FlexDirection[FlexDirection["ROW"] = 0] = "ROW";
-    FlexDirection[FlexDirection["COLUMN"] = 1] = "COLUMN";
-})(FlexDirection || (FlexDirection = {}));
-export class FlexGroup extends Component {
-    _active = false;
-    _applyingLayout = false;
-    _direction = FlexDirection.ROW;
-    get direction() {
-        return this._direction;
-    }
-    set direction(val) {
-        if (this._direction === val) {
-            return;
-        }
-        this._direction = val;
-        this.markResize();
-    }
-    _gap = 0;
-    get gap() {
-        return this._gap;
-    }
-    set gap(val) {
-        if (this._gap === val) {
-            return;
-        }
-        this._gap = val;
-        this.markResize();
-    }
-    awake() {
-        this._active = true;
-        this.gameObject.emitter.on(GameObject.Event.RESIZE, this.handleResize, this);
-        this.gameObject.emitter.on(GameObject.Event.CHILD_ADDED, this.handleChildAdded, this);
-        this.gameObject.emitter.on(GameObject.Event.CHILD_REMOVED, this.handleChildRemoved, this);
-        for (const child of this.gameObject.children) {
-            this.bindChild(child);
-        }
-        this.resize();
-    }
-    handleResize = () => {
-        this.markResize();
-    };
-    handleChildAdded = (child) => {
-        this.bindChild(child);
-        this.markResize();
-    };
-    handleChildRemoved = (child) => {
-        this.unbindChild(child);
-        this.markResize();
-    };
-    handleChildResize = () => {
-        if (this._applyingLayout) {
-            return;
-        }
-        this.markResize();
-    };
-    bindChild(child) {
-        child.emitter.on(GameObject.Event.RESIZE, this.handleChildResize, this);
-    }
-    unbindChild(child) {
-        child.emitter.off(GameObject.Event.RESIZE, this.handleChildResize, this);
-    }
-    markResize() {
-        if (this._active) {
-            this.resize();
-        }
-    }
-    resize = onlyOnceQueueMicrotask(() => {
-        if (!this._active && !this.gameObject.display) {
-            return;
-        }
-        const length = this.gameObject.children.length;
-        if (length === 0) {
-            return;
-        }
-        const isRow = this.direction === FlexDirection.ROW;
-        let total = 0;
-        let fixedSize = Math.max(0, length - 1) * this.gap;
-        for (let i = 0; i < length; i++) {
-            const child = this.gameObject.getChildAt(i);
-            const flex = child.getComponent(Flex);
-            if (flex && flex.grow > 0) {
-                total += flex.grow;
-            }
-            else {
-                fixedSize += isRow ? child.width : child.height;
-            }
-        }
-        // 起始位置
-        let location = 0;
-        // 可用空间
-        const available = Math.max(0, (isRow ? this.gameObject.width : this.gameObject.height) - fixedSize);
-        this._applyingLayout = true;
-        try {
-            for (let i = 0; i < length; i++) {
-                const child = this.gameObject.getChildAt(i);
-                const flex = child.getComponent(Flex);
-                const perc = flex && flex.grow > 0 && total > 0 ? flex.grow / total : 0;
-                if (isRow) {
-                    child.x = location;
-                    if (perc) {
-                        child.width = available * perc;
-                    }
-                    location += child.width;
-                }
-                else {
-                    child.y = location;
-                    if (perc) {
-                        child.height = available * perc;
-                    }
-                    location += child.height;
-                }
-                if (i < length - 1) {
-                    location += this.gap;
-                }
-            }
-        }
-        finally {
-            this._applyingLayout = false;
-        }
-    });
-    onDestroy() {
-        this._active = false;
-        this.gameObject.emitter.off(GameObject.Event.RESIZE, this.handleResize, this);
-        this.gameObject.emitter.off(GameObject.Event.CHILD_ADDED, this.handleChildAdded, this);
-        this.gameObject.emitter.off(GameObject.Event.CHILD_REMOVED, this.handleChildRemoved, this);
-        for (const child of this.gameObject.children) {
-            this.unbindChild(child);
-        }
-    }
-}

package/dist/runtime/component/GridLayout.d.ts

@@ -1,47 +0,0 @@
-import { Group } from "../group/index.js";
-import { Component } from "./Component.js";
-export declare class GridLayout extends Component<Group> {
-    private _active;
-    private _refresh;
-    /**
-     * 横向列数。
-     */
-    private _col;
-    get col(): number;
-    set col(val: number);
-    /**
-     * 单元格宽度。
-     */
-    private _gridWidth;
-    get gridWidth(): number;
-    set gridWidth(val: number);
-    /**
-     * 单元格高度。
-     */
-    private _gridHeight;
-    get gridHeight(): number;
-    set gridHeight(val: number);
-    /**
-     * 横向间距，作用于 x 轴。
-     */
-    private _gapHorizontal;
-    get gapHorizontal(): number;
-    set gapHorizontal(val: number);
-    /**
-     * 纵向间距，作用于 y 轴。
-     */
-    private _gapVertical;
-    get gapVertical(): number;
-    set gapVertical(val: number);
-    private resizeLater;
-    private handleChildAdded;
-    private handleChildRemoved;
-    awake(): void;
-    private normalizeCount;
-    private markResize;
-    /**
-     * 计算布局
-     */
-    resize(): void;
-    onDestroy(): void;
-}

package/dist/runtime/component/GridLayout.js

@@ -1,129 +0,0 @@
-import { GameObject } from "../GameObject.js";
-import { Component } from "./Component.js";
-import { onlyOnceQueueMicrotask } from "../utils/onlyOnceQueueMicrotask.js";
-export class GridLayout extends Component {
-    _active = false;
-    _refresh = false;
-    /**
-     * 横向列数。
-     */
-    _col = 1;
-    get col() {
-        return this._col;
-    }
-    set col(val) {
-        const next = this.normalizeCount(val);
-        if (this._col === next) {
-            return;
-        }
-        this._col = next;
-        this.markResize();
-    }
-    /**
-     * 单元格宽度。
-     */
-    _gridWidth = 1;
-    get gridWidth() {
-        return this._gridWidth;
-    }
-    set gridWidth(val) {
-        if (this._gridWidth === val) {
-            return;
-        }
-        this._gridWidth = val;
-        this.markResize();
-    }
-    /**
-     * 单元格高度。
-     */
-    _gridHeight = 1;
-    get gridHeight() {
-        return this._gridHeight;
-    }
-    set gridHeight(val) {
-        if (this._gridHeight === val) {
-            return;
-        }
-        this._gridHeight = val;
-        this.markResize();
-    }
-    /**
-     * 横向间距，作用于 x 轴。
-     */
-    _gapHorizontal = 0;
-    get gapHorizontal() {
-        return this._gapHorizontal;
-    }
-    set gapHorizontal(val) {
-        if (this._gapHorizontal === val) {
-            return;
-        }
-        this._gapHorizontal = val;
-        this.markResize();
-    }
-    /**
-     * 纵向间距，作用于 y 轴。
-     */
-    _gapVertical = 0;
-    get gapVertical() {
-        return this._gapVertical;
-    }
-    set gapVertical(val) {
-        if (this._gapVertical === val) {
-            return;
-        }
-        this._gapVertical = val;
-        this.markResize();
-    }
-    resizeLater = onlyOnceQueueMicrotask(() => {
-        if (!this._active || !this._refresh) {
-            return;
-        }
-        this.resize();
-    });
-    handleChildAdded = () => {
-        this.markResize();
-    };
-    handleChildRemoved = () => {
-        this.markResize();
-    };
-    awake() {
-        this._active = true;
-        this.gameObject.emitter.on(GameObject.Event.CHILD_ADDED, this.handleChildAdded, this);
-        this.gameObject.emitter.on(GameObject.Event.CHILD_REMOVED, this.handleChildRemoved, this);
-        this.resize();
-    }
-    normalizeCount(val) {
-        if (!Number.isFinite(val)) {
-            return 1;
-        }
-        return Math.max(1, Math.floor(val));
-    }
-    markResize() {
-        this._refresh = true;
-        if (this._active) {
-            this.resizeLater();
-        }
-    }
-    /**
-     * 计算布局
-     */
-    resize() {
-        this._refresh = false;
-        const children = this.gameObject.children;
-        const colCount = this.col;
-        for (let i = 0; i < children.length; i++) {
-            const child = children[i];
-            child.width = this.gridWidth;
-            child.height = this.gridHeight;
-            const col = i % colCount;
-            const row = Math.floor(i / colCount);
-            child.transform.setPosition(col * (this.gridWidth + this.gapHorizontal), row * (this.gridHeight + this.gapVertical));
-        }
-    }
-    onDestroy() {
-        this._active = false;
-        this.gameObject.emitter.off(GameObject.Event.CHILD_ADDED, this.handleChildAdded, this);
-        this.gameObject.emitter.off(GameObject.Event.CHILD_REMOVED, this.handleChildRemoved, this);
-    }
-}