pixifact 0.1.3

package/dist/nodes/components/ScrollRect.d.ts

@@ -0,0 +1,23 @@
+import { Component } from "../../runtime/index.js";
+import type { Group } from "../../runtime/index.js";
+export declare class ScrollRect extends Component<Group> {
+    viewport?: Group;
+    content?: Group;
+    contentHeight: number;
+    wheelSensitivity: number;
+    dragEnabled: boolean;
+    private scrollY;
+    private dragging;
+    private dragStartY;
+    private dragStartScrollY;
+    awake(): void;
+    get maxScrollY(): number;
+    scrollTo(y: number): void;
+    scrollBy(deltaY: number): void;
+    private applyScroll;
+    private handleWheel;
+    private handlePointerDown;
+    private handleGlobalPointerMove;
+    private handlePointerUp;
+    onDestroy(): void;
+}

package/dist/nodes/components/ScrollRect.js

@@ -0,0 +1,108 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Rectangle } from "pixi.js";
+import { Component, ComponentMeta, Prop } from "../../runtime/index.js";
+let ScrollRect = class ScrollRect extends Component {
+    viewport;
+    content;
+    contentHeight = 0;
+    wheelSensitivity = 1;
+    dragEnabled = true;
+    scrollY = 0;
+    dragging = false;
+    dragStartY = 0;
+    dragStartScrollY = 0;
+    awake() {
+        const target = this.viewport ?? this.gameObject;
+        target.display.eventMode = 'static';
+        target.display.hitArea = new Rectangle(0, 0, target.width, target.height);
+        target.display.on('wheel', this.handleWheel, this);
+        target.display.on('pointerdown', this.handlePointerDown, this);
+        target.display.on('globalpointermove', this.handleGlobalPointerMove, this);
+        target.display.on('pointerup', this.handlePointerUp, this);
+        target.display.on('pointerupoutside', this.handlePointerUp, this);
+        target.display.on('pointercancel', this.handlePointerUp, this);
+        this.applyScroll();
+    }
+    get maxScrollY() {
+        const viewport = this.viewport ?? this.gameObject;
+        return Math.max(0, this.contentHeight - viewport.height);
+    }
+    scrollTo(y) {
+        this.scrollY = Math.min(Math.max(0, y), this.maxScrollY);
+        this.applyScroll();
+    }
+    scrollBy(deltaY) {
+        this.scrollTo(this.scrollY + deltaY);
+    }
+    applyScroll() {
+        if (this.content) {
+            this.content.y = -this.scrollY;
+        }
+    }
+    handleWheel(event) {
+        if (this.maxScrollY <= 0) {
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        this.scrollBy(event.deltaY * this.wheelSensitivity);
+    }
+    handlePointerDown(event) {
+        if (!this.dragEnabled || this.maxScrollY <= 0) {
+            return;
+        }
+        this.dragging = true;
+        this.dragStartY = event.global.y;
+        this.dragStartScrollY = this.scrollY;
+        event.stopPropagation();
+    }
+    handleGlobalPointerMove(event) {
+        if (!this.dragging) {
+            return;
+        }
+        this.scrollTo(this.dragStartScrollY - (event.global.y - this.dragStartY));
+        event.stopPropagation();
+    }
+    handlePointerUp() {
+        this.dragging = false;
+    }
+    onDestroy() {
+        const target = this.viewport ?? this.gameObject;
+        target.display.off('wheel', this.handleWheel, this);
+        target.display.off('pointerdown', this.handlePointerDown, this);
+        target.display.off('globalpointermove', this.handleGlobalPointerMove, this);
+        target.display.off('pointerup', this.handlePointerUp, this);
+        target.display.off('pointerupoutside', this.handlePointerUp, this);
+        target.display.off('pointercancel', this.handlePointerUp, this);
+    }
+};
+__decorate([
+    Prop({ type: 'nodeRef', description: 'Viewport node that receives scroll input.' })
+], ScrollRect.prototype, "viewport", void 0);
+__decorate([
+    Prop({ type: 'nodeRef', description: 'Content node moved by scroll input.' })
+], ScrollRect.prototype, "content", void 0);
+__decorate([
+    Prop({ type: 'number', default: 0, min: 0 })
+], ScrollRect.prototype, "contentHeight", void 0);
+__decorate([
+    Prop({ type: 'number', default: 1 })
+], ScrollRect.prototype, "wheelSensitivity", void 0);
+__decorate([
+    Prop({ type: 'boolean', default: true })
+], ScrollRect.prototype, "dragEnabled", void 0);
+ScrollRect = __decorate([
+    ComponentMeta({
+        type: 'ui.ScrollRect',
+        displayName: 'Scroll Rect',
+        category: 'UI/Interaction',
+        description: 'Moves a content node inside a viewport using wheel and drag input.',
+        disallowMultiple: true,
+    })
+], ScrollRect);
+export { ScrollRect };

package/dist/nodes/components/Selectable.d.ts

@@ -0,0 +1,32 @@
+import { Component } from "../../runtime/index.js";
+import type { FederatedPointerEvent } from "pixi.js";
+import type { Group } from "../../runtime/index.js";
+import type { RoundedRectGraphic } from "../graphics/index.js";
+export declare enum SelectionState {
+    Normal = "normal",
+    Highlighted = "highlighted",
+    Pressed = "pressed",
+    Disabled = "disabled"
+}
+export declare class Selectable extends Component<Group> {
+    interactable: boolean;
+    targetGraphic?: RoundedRectGraphic;
+    transition: 'none' | 'colorTint' | 'scale';
+    normalColor: number;
+    highlightedColor: number;
+    pressedColor: number;
+    disabledColor: number;
+    pressedScale: number;
+    protected hovered: boolean;
+    protected pressed: boolean;
+    awake(): void;
+    protected handlePointerOver(_event: FederatedPointerEvent): void;
+    protected handlePointerOut(_event: FederatedPointerEvent): void;
+    protected handlePointerDown(_event: FederatedPointerEvent): void;
+    protected handlePointerUp(_event: FederatedPointerEvent): void;
+    protected handlePointerCancel(_event: FederatedPointerEvent): void;
+    protected get state(): SelectionState;
+    protected applyState(): void;
+    private get currentColor();
+    onDestroy(): void;
+}

package/dist/nodes/components/Selectable.js

@@ -0,0 +1,153 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Component, ComponentMeta, Prop } from "../../runtime/index.js";
+export var SelectionState;
+(function (SelectionState) {
+    SelectionState["Normal"] = "normal";
+    SelectionState["Highlighted"] = "highlighted";
+    SelectionState["Pressed"] = "pressed";
+    SelectionState["Disabled"] = "disabled";
+})(SelectionState || (SelectionState = {}));
+let Selectable = class Selectable extends Component {
+    interactable = true;
+    targetGraphic;
+    transition = 'colorTint';
+    normalColor = 0x2563eb;
+    highlightedColor = 0x1d4ed8;
+    pressedColor = 0x1e40af;
+    disabledColor = 0x94a3b8;
+    pressedScale = 0.96;
+    hovered = false;
+    pressed = false;
+    awake() {
+        this.gameObject.display.eventMode = this.interactable ? 'static' : 'none';
+        this.gameObject.display.cursor = this.interactable ? 'pointer' : 'default';
+        this.gameObject.display.on('pointerover', this.handlePointerOver, this);
+        this.gameObject.display.on('pointerout', this.handlePointerOut, this);
+        this.gameObject.display.on('pointerdown', this.handlePointerDown, this);
+        this.gameObject.display.on('pointerup', this.handlePointerUp, this);
+        this.gameObject.display.on('pointerupoutside', this.handlePointerCancel, this);
+        this.gameObject.display.on('pointercancel', this.handlePointerCancel, this);
+        this.applyState();
+    }
+    handlePointerOver(_event) {
+        if (!this.interactable) {
+            return;
+        }
+        this.hovered = true;
+        this.applyState();
+    }
+    handlePointerOut(_event) {
+        this.hovered = false;
+        this.pressed = false;
+        this.applyState();
+    }
+    handlePointerDown(_event) {
+        if (!this.interactable) {
+            return;
+        }
+        this.pressed = true;
+        this.applyState();
+    }
+    handlePointerUp(_event) {
+        if (!this.interactable) {
+            return;
+        }
+        this.pressed = false;
+        this.applyState();
+    }
+    handlePointerCancel(_event) {
+        this.pressed = false;
+        this.applyState();
+    }
+    get state() {
+        if (!this.interactable) {
+            return SelectionState.Disabled;
+        }
+        if (this.pressed) {
+            return SelectionState.Pressed;
+        }
+        if (this.hovered) {
+            return SelectionState.Highlighted;
+        }
+        return SelectionState.Normal;
+    }
+    applyState() {
+        this.gameObject.display.eventMode = this.interactable ? 'static' : 'none';
+        this.gameObject.display.cursor = this.interactable ? 'pointer' : 'default';
+        if (this.transition === 'colorTint' && this.targetGraphic) {
+            this.targetGraphic.color = this.currentColor;
+            this.targetGraphic.setDirty();
+        }
+        if (this.transition === 'scale') {
+            const scale = this.state === SelectionState.Pressed ? this.pressedScale : 1;
+            this.gameObject.scaleX = scale;
+            this.gameObject.scaleY = scale;
+        }
+    }
+    get currentColor() {
+        switch (this.state) {
+            case SelectionState.Disabled:
+                return this.disabledColor;
+            case SelectionState.Pressed:
+                return this.pressedColor;
+            case SelectionState.Highlighted:
+                return this.highlightedColor;
+            default:
+                return this.normalColor;
+        }
+    }
+    onDestroy() {
+        this.gameObject.display.off('pointerover', this.handlePointerOver, this);
+        this.gameObject.display.off('pointerout', this.handlePointerOut, this);
+        this.gameObject.display.off('pointerdown', this.handlePointerDown, this);
+        this.gameObject.display.off('pointerup', this.handlePointerUp, this);
+        this.gameObject.display.off('pointerupoutside', this.handlePointerCancel, this);
+        this.gameObject.display.off('pointercancel', this.handlePointerCancel, this);
+    }
+};
+__decorate([
+    Prop({ type: 'boolean', default: true })
+], Selectable.prototype, "interactable", void 0);
+__decorate([
+    Prop({
+        type: 'componentRef',
+        component: 'ui.Graphic',
+        description: 'Graphic changed by this selectable transition.',
+    })
+], Selectable.prototype, "targetGraphic", void 0);
+__decorate([
+    Prop({
+        type: 'enum',
+        default: 'colorTint',
+        options: ['none', 'colorTint', 'scale'],
+    })
+], Selectable.prototype, "transition", void 0);
+__decorate([
+    Prop({ type: 'color', default: 0x2563eb })
+], Selectable.prototype, "normalColor", void 0);
+__decorate([
+    Prop({ type: 'color', default: 0x1d4ed8 })
+], Selectable.prototype, "highlightedColor", void 0);
+__decorate([
+    Prop({ type: 'color', default: 0x1e40af })
+], Selectable.prototype, "pressedColor", void 0);
+__decorate([
+    Prop({ type: 'color', default: 0x94a3b8 })
+], Selectable.prototype, "disabledColor", void 0);
+__decorate([
+    Prop({ type: 'number', default: 0.96, min: 0 })
+], Selectable.prototype, "pressedScale", void 0);
+Selectable = __decorate([
+    ComponentMeta({
+        type: 'ui.Selectable',
+        displayName: 'Selectable',
+        category: 'UI/Interaction',
+        description: 'Base class for pointer-driven selectable controls.',
+    })
+], Selectable);
+export { Selectable };

package/dist/nodes/components/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Selectable.js';
+export { Button as ButtonComponent } from './Button.js';
+export * from './ProgressBar.js';
+export * from './ScrollRect.js';
+export * from './InputField.js';

package/dist/nodes/components/index.js

@@ -0,0 +1,5 @@
+export * from './Selectable.js';
+export { Button as ButtonComponent } from './Button.js';
+export * from './ProgressBar.js';
+export * from './ScrollRect.js';
+export * from './InputField.js';

package/dist/nodes/graphics/Graphic.d.ts

@@ -0,0 +1,14 @@
+import { Container } from "pixi.js";
+import { Component } from "../../runtime/index.js";
+import type { Group } from "../../runtime/index.js";
+export declare abstract class Graphic<TDisplay extends Container = Container> extends Component<Group> {
+    display: TDisplay;
+    private _dirty;
+    raycastTarget: boolean;
+    awake(): void;
+    protected abstract createDisplay(): void;
+    protected abstract redraw(): void;
+    setDirty(): void;
+    private redrawNow;
+    onDestroy(): void;
+}

package/dist/nodes/graphics/Graphic.js

@@ -0,0 +1,47 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Component, ComponentMeta, Prop } from "../../runtime/index.js";
+let Graphic = class Graphic extends Component {
+    display;
+    _dirty = true;
+    raycastTarget = true;
+    awake() {
+        this.createDisplay();
+        this.gameObject.display.addChild(this.display);
+        this.redrawNow();
+    }
+    setDirty() {
+        this._dirty = true;
+        this.redrawNow();
+    }
+    redrawNow() {
+        if (!this._dirty || !this.display) {
+            return;
+        }
+        this._dirty = false;
+        this.redraw();
+    }
+    onDestroy() {
+        this.display?.destroy();
+    }
+};
+__decorate([
+    Prop({
+        type: 'boolean',
+        default: true,
+        description: 'Whether this graphic can be used as an interaction raycast target.',
+    })
+], Graphic.prototype, "raycastTarget", void 0);
+Graphic = __decorate([
+    ComponentMeta({
+        type: 'ui.Graphic',
+        displayName: 'Graphic',
+        category: 'UI/Graphic',
+        description: 'Base class for renderable UI graphics.',
+    })
+], Graphic);
+export { Graphic };

package/dist/nodes/graphics/ImageGraphic.d.ts

@@ -0,0 +1,9 @@
+import { Sprite } from "pixi.js";
+import { Graphic } from "./Graphic.js";
+export declare class ImageGraphic extends Graphic<Sprite> {
+    src: string;
+    tint: number;
+    protected createDisplay(): void;
+    protected redraw(): void;
+    onDestroy(): void;
+}

package/dist/nodes/graphics/ImageGraphic.js

@@ -0,0 +1,42 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Sprite, Texture } from "pixi.js";
+import { ComponentMeta, GameObject, Prop } from "../../runtime/index.js";
+import { Graphic } from "./Graphic.js";
+let ImageGraphic = class ImageGraphic extends Graphic {
+    src = '';
+    tint = 0xffffff;
+    createDisplay() {
+        this.display = new Sprite(Texture.EMPTY);
+        this.gameObject.emitter.on(GameObject.Event.RESIZE, this.setDirty, this);
+    }
+    redraw() {
+        this.display.texture = this.src ? Texture.from(this.src) : Texture.EMPTY;
+        this.display.width = this.gameObject.width;
+        this.display.height = this.gameObject.height;
+        this.display.tint = this.tint;
+    }
+    onDestroy() {
+        this.gameObject.emitter.off(GameObject.Event.RESIZE, this.setDirty, this);
+        super.onDestroy();
+    }
+};
+__decorate([
+    Prop({ type: 'assetRef', default: '', assetType: 'image' })
+], ImageGraphic.prototype, "src", void 0);
+__decorate([
+    Prop({ type: 'color', default: 0xffffff })
+], ImageGraphic.prototype, "tint", void 0);
+ImageGraphic = __decorate([
+    ComponentMeta({
+        type: 'ui.ImageGraphic',
+        displayName: 'Image',
+        category: 'UI/Graphic',
+        description: 'Draws an image sprite using the host group logical size.',
+    })
+], ImageGraphic);
+export { ImageGraphic };

package/dist/nodes/graphics/RoundedRectGraphic.d.ts

@@ -0,0 +1,13 @@
+import { Graphics as PixiGraphics } from "pixi.js";
+import { Graphic } from "./Graphic.js";
+export declare class RoundedRectGraphic extends Graphic<PixiGraphics> {
+    color: number;
+    fillAlpha: number;
+    radius: number;
+    strokeColor: number;
+    strokeWidth: number;
+    strokeAlpha: number;
+    protected createDisplay(): void;
+    protected redraw(): void;
+    onDestroy(): void;
+}

package/dist/nodes/graphics/RoundedRectGraphic.js

@@ -0,0 +1,65 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Graphics as PixiGraphics } from "pixi.js";
+import { ComponentMeta, GameObject, Prop } from "../../runtime/index.js";
+import { Graphic } from "./Graphic.js";
+let RoundedRectGraphic = class RoundedRectGraphic extends Graphic {
+    color = 0xffffff;
+    fillAlpha = 1;
+    radius = 0;
+    strokeColor = 0x000000;
+    strokeWidth = 0;
+    strokeAlpha = 1;
+    createDisplay() {
+        this.display = new PixiGraphics();
+        this.gameObject.emitter.on(GameObject.Event.RESIZE, this.setDirty, this);
+    }
+    redraw() {
+        this.display.clear();
+        this.display
+            .roundRect(0, 0, this.gameObject.width, this.gameObject.height, this.radius)
+            .fill({ color: this.color, alpha: this.fillAlpha });
+        if (this.strokeWidth > 0) {
+            this.display.stroke({
+                width: this.strokeWidth,
+                color: this.strokeColor,
+                alpha: this.strokeAlpha,
+            });
+        }
+    }
+    onDestroy() {
+        this.gameObject.emitter.off(GameObject.Event.RESIZE, this.setDirty, this);
+        super.onDestroy();
+    }
+};
+__decorate([
+    Prop({ type: 'color', default: 0xffffff })
+], RoundedRectGraphic.prototype, "color", void 0);
+__decorate([
+    Prop({ type: 'number', default: 1, min: 0, max: 1 })
+], RoundedRectGraphic.prototype, "fillAlpha", void 0);
+__decorate([
+    Prop({ type: 'number', default: 0, min: 0 })
+], RoundedRectGraphic.prototype, "radius", void 0);
+__decorate([
+    Prop({ type: 'color', default: 0x000000 })
+], RoundedRectGraphic.prototype, "strokeColor", void 0);
+__decorate([
+    Prop({ type: 'number', default: 0, min: 0 })
+], RoundedRectGraphic.prototype, "strokeWidth", void 0);
+__decorate([
+    Prop({ type: 'number', default: 1, min: 0, max: 1 })
+], RoundedRectGraphic.prototype, "strokeAlpha", void 0);
+RoundedRectGraphic = __decorate([
+    ComponentMeta({
+        type: 'ui.RoundedRectGraphic',
+        displayName: 'Rounded Rect',
+        category: 'UI/Graphic',
+        description: 'Draws a rounded rectangle using the host group logical size.',
+    })
+], RoundedRectGraphic);
+export { RoundedRectGraphic };

package/dist/nodes/graphics/TextGraphic.d.ts

@@ -0,0 +1,13 @@
+import { Text } from "pixi.js";
+import type { TextStyleFontWeight } from "pixi.js";
+import { Graphic } from "./Graphic.js";
+export declare class TextGraphic extends Graphic<Text> {
+    text: string;
+    color: number;
+    fontSize: number;
+    fontFamily: string | string[];
+    fontWeight: TextStyleFontWeight;
+    center: boolean;
+    protected createDisplay(): void;
+    protected redraw(): void;
+}

package/dist/nodes/graphics/TextGraphic.js

@@ -0,0 +1,70 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Text } from "pixi.js";
+import { ComponentMeta, Prop } from "../../runtime/index.js";
+import { Graphic } from "./Graphic.js";
+let TextGraphic = class TextGraphic extends Graphic {
+    text = '';
+    color = 0x000000;
+    fontSize = 14;
+    fontFamily = 'Arial';
+    fontWeight = 'normal';
+    center = false;
+    createDisplay() {
+        this.display = new Text();
+    }
+    redraw() {
+        this.display.text = this.text;
+        this.display.style = {
+            fill: this.color,
+            fontFamily: this.fontFamily,
+            fontSize: this.fontSize,
+            fontWeight: this.fontWeight,
+        };
+        if (this.center) {
+            this.display.anchor.set(0.5);
+            this.display.x = this.gameObject.width / 2;
+            this.display.y = this.gameObject.height / 2;
+        }
+        else {
+            this.display.anchor.set(0);
+            this.display.x = 0;
+            this.display.y = 0;
+        }
+    }
+};
+__decorate([
+    Prop({ type: 'string', default: '' })
+], TextGraphic.prototype, "text", void 0);
+__decorate([
+    Prop({ type: 'color', default: 0x000000 })
+], TextGraphic.prototype, "color", void 0);
+__decorate([
+    Prop({ type: 'number', default: 14, min: 1 })
+], TextGraphic.prototype, "fontSize", void 0);
+__decorate([
+    Prop({ type: 'string', default: 'Arial' })
+], TextGraphic.prototype, "fontFamily", void 0);
+__decorate([
+    Prop({
+        type: 'enum',
+        default: 'normal',
+        options: ['normal', 'bold', 'bolder', 'lighter', '100', '200', '300', '400', '500', '600', '700', '800', '900'],
+    })
+], TextGraphic.prototype, "fontWeight", void 0);
+__decorate([
+    Prop({ type: 'boolean', default: false })
+], TextGraphic.prototype, "center", void 0);
+TextGraphic = __decorate([
+    ComponentMeta({
+        type: 'ui.TextGraphic',
+        displayName: 'Text',
+        category: 'UI/Graphic',
+        description: 'Draws a text label on the host group.',
+    })
+], TextGraphic);
+export { TextGraphic };

package/dist/nodes/graphics/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Graphic.js';
+export * from './ImageGraphic.js';
+export * from './RoundedRectGraphic.js';
+export * from './TextGraphic.js';

package/dist/nodes/graphics/index.js

@@ -0,0 +1,4 @@
+export * from './Graphic.js';
+export * from './ImageGraphic.js';
+export * from './RoundedRectGraphic.js';
+export * from './TextGraphic.js';

package/dist/nodes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Input.js';
+export * from './Textarea.js';
+export * from './components/index.js';

package/dist/nodes/index.js

@@ -0,0 +1,3 @@
+export * from './Input.js';
+export * from './Textarea.js';
+export * from './components/index.js';

package/dist/runtime/Application.d.ts

@@ -0,0 +1,15 @@
+import * as PIXI from 'pixi.js';
+import type { RendererDestroyOptions, DestroyOptions } from 'pixi.js';
+import { GameObject } from './GameObject.js';
+import { Group } from './group/index.js';
+export declare class Application extends PIXI.Application {
+    root: Group;
+    private updateTargets;
+    private isUpdateTickerRegistered;
+    private updateGameObjects;
+    init(options?: Partial<PIXI.ApplicationOptions>): Promise<void>;
+    registerUpdateTarget(target: GameObject): void;
+    unregisterUpdateTarget(target: GameObject): void;
+    private syncUpdateTicker;
+    destroy(rendererDestroyOptions?: RendererDestroyOptions, options?: DestroyOptions): void;
+}