bard-legends-framework 0.12.1 → 1.0.0-rc0

package/dist/pixi/display-object/container-attributes.d.ts

@@ -1,99 +0,0 @@
-import { IAttachment, IDAttachable } from 'actions-lib';
-import { Radian, Vector } from 'helpers-lib';
-import * as Pixi from 'pixi.js';
-export declare enum ContainerEventType {
-    Click = "click",
-    MouseOver = "mouseover",
-    MouseOut = "mouseout",
-    PointerDown = "pointerdown",
-    PointerUp = "pointerup",
-    PointerUpOutside = "pointerupoutside",
-    PointerMove = "pointermove",
-    PointerCancel = "pointercancel",
-    PointerOver = "pointerover",
-    PointerOut = "pointerout",
-    PointerEnter = "pointerenter",
-    PointerLeave = "pointerleave",
-    Added = "added",
-    Removed = "removed",
-    Update = "update",
-    Change = "change"
-}
-export declare enum Cursor {
-    Default = "default",
-    Pointer = "pointer"
-}
-export declare abstract class ContainerAttributes extends IDAttachable {
-    protected constructor();
-    get size(): Vector;
-    set size(value: Vector);
-    getSize(): Vector;
-    setSize(value: Vector): this;
-    /**
-     * @param value The position to set
-     * @param options.holdFrom An anchor point to hold the position from
-     * @param options.round Default: true
-     * @returns this
-     */
-    setPosition(value: Vector, options?: {
-        holdFrom?: Vector;
-        round?: boolean;
-    }): this;
-    get position(): Vector;
-    set position(value: Vector);
-    get x(): number;
-    set x(value: number);
-    get y(): number;
-    set y(value: number);
-    on(eventType: ContainerEventType, callback: () => void): IAttachment;
-    setRotation(value: Radian): this;
-    get rotation(): Radian;
-    set rotation(value: Radian);
-    /**
-     * Number value of the rotation, in order to be animated
-     */
-    get rotationValue(): number;
-    set rotationValue(value: number);
-    setZIndex(value: number): this;
-    get zIndex(): number;
-    set zIndex(value: number);
-    setSkewX(radian: Radian): this;
-    get skewX(): Radian;
-    set skewX(radian: Radian);
-    setSkewY(radian: Radian): this;
-    get skewY(): Radian;
-    set skewY(radian: Radian);
-    setSortableChildren(value: boolean): this;
-    get sortableChildren(): boolean;
-    set sortableChildren(value: boolean);
-    setAlpha(value: number): this;
-    get alpha(): number;
-    set alpha(value: number);
-    setInteractive(value: boolean): this;
-    get interactive(): boolean;
-    set interactive(value: boolean);
-    setCursor(value: Cursor): this;
-    get cursor(): Cursor;
-    set cursor(value: Cursor);
-    protected getMask(): Pixi.Container;
-    private _mask;
-    setMask(mask: ContainerAttributes | undefined): this;
-    hitTest(stagePosition: Vector): boolean;
-    private _mirror;
-    private _flip;
-    private _scale;
-    private _aspectRatio;
-    setMirror(mirror?: boolean): this;
-    get mirror(): boolean;
-    set mirror(value: boolean);
-    setFlip(flip?: boolean): this;
-    get flip(): boolean;
-    set flip(value: boolean);
-    setScale(value: number): this;
-    get scale(): number;
-    set scale(value: number);
-    setAspectRatio(value: number): this;
-    get aspectRatio(): number;
-    set aspectRatio(value: number);
-    private _updateScale;
-}

package/dist/pixi/display-object/container-attributes.js

@@ -1,313 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContainerAttributes = exports.Cursor = exports.ContainerEventType = void 0;
-const actions_lib_1 = require("actions-lib");
-const helpers_lib_1 = require("helpers-lib");
-const Pixi = __importStar(require("pixi.js"));
-var ContainerEventType;
-(function (ContainerEventType) {
-    ContainerEventType["Click"] = "click";
-    ContainerEventType["MouseOver"] = "mouseover";
-    ContainerEventType["MouseOut"] = "mouseout";
-    ContainerEventType["PointerDown"] = "pointerdown";
-    ContainerEventType["PointerUp"] = "pointerup";
-    ContainerEventType["PointerUpOutside"] = "pointerupoutside";
-    ContainerEventType["PointerMove"] = "pointermove";
-    ContainerEventType["PointerCancel"] = "pointercancel";
-    ContainerEventType["PointerOver"] = "pointerover";
-    ContainerEventType["PointerOut"] = "pointerout";
-    ContainerEventType["PointerEnter"] = "pointerenter";
-    ContainerEventType["PointerLeave"] = "pointerleave";
-    ContainerEventType["Added"] = "added";
-    ContainerEventType["Removed"] = "removed";
-    ContainerEventType["Update"] = "update";
-    ContainerEventType["Change"] = "change";
-})(ContainerEventType || (exports.ContainerEventType = ContainerEventType = {}));
-var Cursor;
-(function (Cursor) {
-    Cursor["Default"] = "default";
-    Cursor["Pointer"] = "pointer";
-})(Cursor || (exports.Cursor = Cursor = {}));
-class ContainerAttributes extends actions_lib_1.IDAttachable {
-    constructor() {
-        super();
-        // --------------------- Scale ---------------------
-        this._mirror = false;
-        this._flip = false;
-        this._scale = 1;
-        this._aspectRatio = 1;
-        this.pixiContainer = new Pixi.Container();
-    }
-    get size() {
-        return this.getSize();
-    }
-    set size(value) {
-        this.setSize(value);
-    }
-    getSize() {
-        return new helpers_lib_1.Vector(this.pixiContainer.width, this.pixiContainer.height);
-    }
-    setSize(value) {
-        this.pixiContainer.width = value.x;
-        this.pixiContainer.height = value.y;
-        return this;
-    }
-    /**
-     * @param value The position to set
-     * @param options.holdFrom An anchor point to hold the position from
-     * @param options.round Default: true
-     * @returns this
-     */
-    setPosition(value, options) {
-        if (options?.holdFrom) {
-            let bounds = this.pixiContainer.getLocalBounds();
-            let scaleWithAspectRatio = new helpers_lib_1.Vector(this.pixiContainer.scale.x, this.pixiContainer.scale.y);
-            let topLeft = new helpers_lib_1.Vector(bounds.x, bounds.y).multiply(scaleWithAspectRatio);
-            let size = new helpers_lib_1.Vector(bounds.width, bounds.height).multiply(scaleWithAspectRatio);
-            let modifier = topLeft.add(size.multiply(options.holdFrom));
-            value = value.subtract(modifier);
-        }
-        if (options?.round !== false) {
-            value = value.round({ rollHalfsDown: true });
-        }
-        this.position = value;
-        return this;
-    }
-    get position() {
-        return new helpers_lib_1.Vector(this.pixiContainer.x, this.pixiContainer.y);
-    }
-    set position(value) {
-        this.pixiContainer.position = value;
-    }
-    get x() {
-        return this.pixiContainer.x;
-    }
-    set x(value) {
-        this.pixiContainer.x = value;
-    }
-    get y() {
-        return this.pixiContainer.y;
-    }
-    set y(value) {
-        this.pixiContainer.y = value;
-    }
-    on(eventType, callback) {
-        // Pixijs has a bug, the callbacks are triggered twice https://github.com/pixijs/pixijs/issues/10131
-        let handle = (event) => callback();
-        this.pixiContainer.on(eventType, handle);
-        return new actions_lib_1.ActionSubscription(() => {
-            this.pixiContainer.off(eventType, handle);
-        });
-    }
-    setRotation(value) {
-        this.rotation = value;
-        return this;
-    }
-    get rotation() {
-        return new helpers_lib_1.Radian(this.pixiContainer.rotation);
-    }
-    set rotation(value) {
-        this.pixiContainer.rotation = value.value;
-    }
-    /**
-     * Number value of the rotation, in order to be animated
-     */
-    get rotationValue() {
-        return this.rotation.value;
-    }
-    set rotationValue(value) {
-        this.rotation = new helpers_lib_1.Radian(value);
-    }
-    setZIndex(value) {
-        this.zIndex = value;
-        return this;
-    }
-    get zIndex() {
-        return this.pixiContainer.zIndex;
-    }
-    set zIndex(value) {
-        this.pixiContainer.zIndex = value;
-    }
-    setSkewX(radian) {
-        this.skewX = radian;
-        return this;
-    }
-    get skewX() {
-        return new helpers_lib_1.Radian(this.pixiContainer.skew.x);
-    }
-    set skewX(radian) {
-        this.pixiContainer.skew.x = radian.value;
-    }
-    setSkewY(radian) {
-        this.skewY = radian;
-        return this;
-    }
-    get skewY() {
-        return new helpers_lib_1.Radian(this.pixiContainer.skew.y);
-    }
-    set skewY(radian) {
-        this.pixiContainer.skew.y = radian.value;
-    }
-    setSortableChildren(value) {
-        this.sortableChildren = value;
-        return this;
-    }
-    get sortableChildren() {
-        return this.pixiContainer.sortableChildren;
-    }
-    set sortableChildren(value) {
-        this.pixiContainer.sortableChildren = value;
-    }
-    setAlpha(value) {
-        this.pixiContainer.alpha = value;
-        return this;
-    }
-    get alpha() {
-        return this.pixiContainer.alpha;
-    }
-    set alpha(value) {
-        this.pixiContainer.alpha = value;
-    }
-    setInteractive(value) {
-        this.interactive = value;
-        return this;
-    }
-    get interactive() {
-        return this.pixiContainer.interactive;
-    }
-    set interactive(value) {
-        if (value) {
-            this.pixiContainer.eventMode = 'dynamic';
-        }
-        else {
-            this.pixiContainer.eventMode = 'none';
-        }
-    }
-    setCursor(value) {
-        this.cursor = value;
-        return this;
-    }
-    get cursor() {
-        return this.pixiContainer.cursor;
-    }
-    set cursor(value) {
-        this.pixiContainer.cursor = value;
-    }
-    getMask() {
-        throw new Error(`ContainerAttributes: mask is not available!`);
-    }
-    setMask(mask) {
-        if (mask) {
-            this.pixiContainer.addChild(mask.pixiContainer);
-            this.pixiContainer.mask = mask.getMask();
-            this._mask = mask;
-        }
-        else {
-            if (this._mask) {
-                this.pixiContainer.removeChild(this._mask.pixiContainer);
-            }
-            // biome-ignore lint:all
-            this.pixiContainer.mask = null;
-        }
-        return this;
-    }
-    hitTest(stagePosition) {
-        if (this.pixiContainer.parent) {
-            if (this.pixiContainer.hitArea) {
-                let localPosition = this.pixiContainer.toLocal(stagePosition);
-                return this.pixiContainer.hitArea.contains(localPosition.x, localPosition.y);
-            }
-            else {
-                let bounds = this.pixiContainer.getBounds();
-                return bounds.contains(stagePosition.x, stagePosition.y);
-            }
-        }
-        else {
-            return false;
-        }
-    }
-    setMirror(mirror = false) {
-        this.mirror = mirror;
-        return this;
-    }
-    get mirror() {
-        return this._mirror;
-    }
-    set mirror(value) {
-        this._mirror = value;
-        this._updateScale();
-    }
-    setFlip(flip = false) {
-        this.flip = flip;
-        return this;
-    }
-    get flip() {
-        return this._flip;
-    }
-    set flip(value) {
-        this._flip = value;
-        this._updateScale();
-    }
-    setScale(value) {
-        this.scale = value;
-        return this;
-    }
-    get scale() {
-        return this._scale;
-    }
-    set scale(value) {
-        this._scale = value;
-        this._updateScale();
-    }
-    setAspectRatio(value) {
-        this.aspectRatio = value;
-        return this;
-    }
-    get aspectRatio() {
-        return this._aspectRatio;
-    }
-    set aspectRatio(value) {
-        this._aspectRatio = value;
-        this._updateScale();
-    }
-    _updateScale() {
-        this.pixiContainer.scale.set(this._scale, this._scale);
-        if (this._aspectRatio < 1) {
-            this.pixiContainer.scale.x *= this._aspectRatio;
-        }
-        else if (this._aspectRatio > 1) {
-            this.pixiContainer.scale.y /= this._aspectRatio;
-        }
-        if (this._mirror) {
-            this.pixiContainer.scale.x *= -1;
-        }
-        if (this._flip) {
-            this.pixiContainer.scale.y *= -1;
-        }
-    }
-}
-exports.ContainerAttributes = ContainerAttributes;
-//# sourceMappingURL=container-attributes.js.map

package/dist/pixi/display-object/container.d.ts

@@ -1,22 +0,0 @@
-import { Rectangle } from 'helpers-lib';
-import { ContainerAttributes } from './container-attributes';
-import { Filters } from './filters';
-import type { Sprite } from './objects/sprite/sprite';
-export interface SetParentOptions {
-    addUnder: boolean;
-    cropOverflowingParts: boolean;
-}
-export declare class Container extends ContainerAttributes {
-    protected static allContainers: Map<number, Container>;
-    readonly filters: Filters;
-    protected addChildTo: Container;
-    protected defaultChildOptions: {
-        addUnder: boolean;
-        cropOverflowingParts: boolean;
-    };
-    constructor();
-    destroy(): void;
-    getBoundingMask(): Sprite;
-    displayParent(parent: Container | number, partialOptions?: Partial<SetParentOptions>): this;
-    get boundingBox(): Rectangle;
-}

package/dist/pixi/display-object/container.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Container = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const container_attributes_1 = require("./container-attributes");
-const filters_1 = require("./filters");
-class Container extends container_attributes_1.ContainerAttributes {
-    static { this.allContainers = new Map(); }
-    constructor() {
-        super();
-        this.addChildTo = this;
-        this.defaultChildOptions = {
-            addUnder: false,
-            cropOverflowingParts: false
-        };
-        Container.allContainers.set(this.id, this);
-        this.filters = new filters_1.Filters(this.pixiContainer);
-    }
-    destroy() {
-        if (!this.destroyed) {
-            super.destroy();
-            Container.allContainers.delete(this.id);
-            !this.pixiContainer.destroyed && this.pixiContainer.destroy();
-        }
-    }
-    getBoundingMask() {
-        if (this.addChildTo !== this) {
-            return this.addChildTo.getBoundingMask();
-        }
-        else {
-            throw new Error(`Container: bounding mask cannot be used without bounding shapes. Display Object: "${this.id}"!`);
-        }
-    }
-    displayParent(parent, partialOptions) {
-        let parentContainer;
-        if (helpers_lib_1.Comparator.isNumber(parent)) {
-            parentContainer = Container.allContainers.get(parent);
-            if (!parentContainer) {
-                throw new Error(`Container: parent not found! id: ${parent}`);
-            }
-        }
-        else {
-            parentContainer = parent;
-        }
-        let options = {
-            addUnder: parentContainer.defaultChildOptions.addUnder,
-            cropOverflowingParts: parentContainer.defaultChildOptions.cropOverflowingParts,
-            ...partialOptions
-        };
-        if (options.addUnder) {
-            parentContainer.addChildTo.pixiContainer.addChildAt(this.pixiContainer, 0);
-        }
-        else {
-            parentContainer.addChildTo.pixiContainer.addChild(this.pixiContainer);
-        }
-        if (options.cropOverflowingParts) {
-            if (parentContainer) {
-                this.pixiContainer.mask = parentContainer.getBoundingMask().pixiSprite;
-            }
-            else {
-                throw new Error(`Container: cropOverflowingParts can only be used with Container parent!`);
-            }
-        }
-        return this;
-    }
-    get boundingBox() {
-        let bounds = this.pixiContainer.getLocalBounds();
-        return new helpers_lib_1.Rectangle(new helpers_lib_1.Vector(bounds.x, bounds.y), new helpers_lib_1.Vector(bounds.x + bounds.width, bounds.y + bounds.height));
-    }
-}
-exports.Container = Container;
-//# sourceMappingURL=container.js.map

package/dist/pixi/display-object/display-object-attributes.d.ts

@@ -1,45 +0,0 @@
-import { Radian, Vector } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
-export declare abstract class DisplayObjectAttributes {
-  pixiContainer: PIXI.Container;
-  private isMirror;
-  protected constructor(pixiContainer: PIXI.Container);
-  get size(): Vector;
-  setPosition(value: Vector): this;
-  get position(): Vector;
-  set position(value: Vector);
-  get x(): number;
-  set x(value: number);
-  get y(): number;
-  set y(value: number);
-  setRotation(value: Radian): this;
-  get rotation(): Radian;
-  set rotation(value: Radian);
-  setZIndex(value: number): this;
-  get zIndex(): number;
-  set zIndex(value: number);
-  setSortableChildren(value: boolean): this;
-  get sortableChildren(): boolean;
-  set sortableChildren(value: boolean);
-  setScale(value: number): this;
-  get scale(): number;
-  set scale(value: number);
-  setAlpha(value: number): this;
-  get alpha(): number;
-  set alpha(value: number);
-  setMirror(mirror?: boolean): this;
-  get mirror(): boolean;
-  set mirror(value: boolean);
-  setInteractive(): this;
-  get interactive(): boolean;
-  set interactive(value: boolean);
-  setPointer(): this;
-  get pointer(): string;
-  set pointer(value: string);
-  setEventMode(eventMode: PIXI.EventMode): this;
-  get eventMode(): PIXI.EventMode;
-  set eventMode(value: PIXI.EventMode);
-  protected getMask(): PIXI.Container;
-  private _mask;
-  setMask(mask: DisplayObjectAttributes | undefined): this;
-}

package/dist/pixi/display-object/display-object-attributes.js

@@ -1,152 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.DisplayObjectAttributes = void 0;
-const helpers_lib_1 = require('helpers-lib');
-class DisplayObjectAttributes {
-  constructor(pixiContainer) {
-    this.pixiContainer = pixiContainer;
-    this.isMirror = false;
-  }
-  get size() {
-    return new helpers_lib_1.Vector(this.pixiContainer.width, this.pixiContainer.height);
-  }
-  setPosition(value) {
-    this.position = value;
-    return this;
-  }
-  get position() {
-    return new helpers_lib_1.Vector(this.pixiContainer.x, this.pixiContainer.y);
-  }
-  set position(value) {
-    this.pixiContainer.position = value;
-  }
-  get x() {
-    return this.pixiContainer.x;
-  }
-  set x(value) {
-    this.x = value;
-  }
-  get y() {
-    return this.pixiContainer.y;
-  }
-  set y(value) {
-    this.pixiContainer.y = value;
-  }
-  setRotation(value) {
-    this.rotation = value;
-    return this;
-  }
-  get rotation() {
-    return new helpers_lib_1.Radian(this.pixiContainer.rotation);
-  }
-  set rotation(value) {
-    this.pixiContainer.rotation = value.value;
-  }
-  setZIndex(value) {
-    this.zIndex = value;
-    return this;
-  }
-  get zIndex() {
-    return this.pixiContainer.zIndex;
-  }
-  set zIndex(value) {
-    this.pixiContainer.zIndex = value;
-  }
-  setSortableChildren(value) {
-    this.sortableChildren = value;
-    return this;
-  }
-  get sortableChildren() {
-    return this.pixiContainer.sortableChildren;
-  }
-  set sortableChildren(value) {
-    this.pixiContainer.sortableChildren = value;
-  }
-  setScale(value) {
-    this.scale = value;
-    return this;
-  }
-  get scale() {
-    if (this.pixiContainer.scale.x !== this.pixiContainer.scale.y) {
-      throw new Error(`DisplayObject: scale x and y are not equal!`);
-    }
-    return this.pixiContainer.scale.x;
-  }
-  set scale(value) {
-    this.pixiContainer.scale.set(value, value);
-    if (this.isMirror) {
-      this.pixiContainer.scale.x *= -1;
-    }
-  }
-  setAlpha(value) {
-    this.pixiContainer.alpha = value;
-    return this;
-  }
-  get alpha() {
-    return this.pixiContainer.alpha;
-  }
-  set alpha(value) {
-    this.pixiContainer.alpha = value;
-  }
-  setMirror(mirror = false) {
-    this.mirror = mirror;
-    return this;
-  }
-  get mirror() {
-    return this.isMirror;
-  }
-  set mirror(value) {
-    this.isMirror = value;
-    if (value) {
-      this.pixiContainer.scale.x *= -1;
-    }
-  }
-  setInteractive() {
-    this.interactive = true;
-    return this;
-  }
-  get interactive() {
-    return this.pixiContainer.interactive;
-  }
-  set interactive(value) {
-    this.pixiContainer.interactive = value;
-  }
-  setPointer() {
-    this.pointer = 'pointer';
-    return this;
-  }
-  get pointer() {
-    return this.pixiContainer.cursor;
-  }
-  set pointer(value) {
-    this.pixiContainer.cursor = value;
-  }
-  setEventMode(eventMode) {
-    this.eventMode = eventMode;
-    return this;
-  }
-  get eventMode() {
-    return this.pixiContainer.eventMode;
-  }
-  set eventMode(value) {
-    this.pixiContainer.eventMode = value;
-  }
-  getMask() {
-    throw new Error(`DisplayObjectAttributes: mask is not available!`);
-  }
-  setMask(mask) {
-    if (mask) {
-      this.pixiContainer.addChild(mask.pixiContainer);
-      this.pixiContainer.mask = mask.getMask();
-      this._mask = mask;
-    } else {
-      if (this._mask) {
-        this.pixiContainer.removeChild(this._mask.pixiContainer);
-      }
-      // eslint-disable-next-line no-null/no-null
-      this.pixiContainer.mask = null;
-    }
-    return this;
-  }
-}
-exports.DisplayObjectAttributes = DisplayObjectAttributes;
-//# sourceMappingURL=display-object-attributes.js.map