bard-legends-framework 0.10.4 → 0.10.6

package/dist/pixi/display-object/objects/text/text.js

@@ -33,7 +33,7 @@ const FONT_SIZE_MULTIPLIER_INVERSE = 1 / FONT_SIZE_MULTIPLIER;
 class Text extends container_1.Container {
     get textMetrics() {
         if (!this._textMetrics) {
-            let pixiTextStyle = new PIXI.TextStyle(this.style);
+            let pixiTextStyle = new PIXI.TextStyle(this.pixiTextStyle);
             this._textMetrics = PIXI.TextMetrics.measureText(this.text, pixiTextStyle);
         }
         return this._textMetrics;
@@ -43,7 +43,8 @@ class Text extends container_1.Container {
     }
     constructor(text, partialOptions) {
         super();
-        this.style = pixi_text_style_converter_1.PixiTextStyleConverter.getPixiTextStyle(partialOptions);
+        this.partialOptions = partialOptions;
+        this.pixiTextStyle = pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle(partialOptions);
         this.setText(text);
     }
     destroySelf() {
@@ -62,7 +63,7 @@ class Text extends container_1.Container {
     }
     setPosition(value, options) {
         if (options?.holdFrom) {
-            let blurDistance = this.style.dropShadowDistance ?? 0;
+            let blurDistance = this.pixiTextStyle.dropShadowDistance ?? 0;
             let shadowOffset = new helpers_lib_1.Vector(options.holdFrom.x * blurDistance, options.holdFrom.y * blurDistance);
             value = value.add(shadowOffset);
         }
@@ -78,19 +79,52 @@ class Text extends container_1.Container {
     }
     setColor(color) {
         let colorHex = helpers_lib_1.ColorHelper.rgbToHex(color);
-        if (this.style.fill !== colorHex) {
-            this.style.fill = colorHex;
+        if (this.pixiTextStyle.fill !== colorHex) {
+            this.pixiTextStyle.fill = colorHex;
             this.regeneratePixiText();
         }
         return this;
     }
     regeneratePixiText() {
         this.pixiText?.destroy();
+        this.strikethroughGraphics?.destroy();
+        this.strikethroughGraphics = undefined;
         this._textMetrics = undefined;
-        let pixiTextStyle = new PIXI.TextStyle(this.style);
+        let pixiTextStyle = new PIXI.TextStyle(this.pixiTextStyle);
         this.pixiText = new PIXI.Text(this.text, pixiTextStyle);
         this.pixiText.scale.set(FONT_SIZE_MULTIPLIER_INVERSE, FONT_SIZE_MULTIPLIER_INVERSE);
         this.pixiContainer.addChild(this.pixiText);
+        if (this.pixiTextStyle.lineThrough) {
+            this.strikethroughGraphics = this.addStrikethroughToText(this.pixiText, this.pixiTextStyle.fill);
+            this.pixiContainer.addChild(this.strikethroughGraphics);
+        }
+    }
+    addStrikethroughToText(pixiText, lineColor) {
+        let textMetrics = PIXI.TextMetrics.measureText(pixiText.text, pixiText.style);
+        let lineThickness = Math.max(1, Math.round(textMetrics.lineHeight * 0.07));
+        let lineOffset = (lineThickness % 2) * 0.5;
+        let strikethroughGraphics = new PIXI.Graphics();
+        strikethroughGraphics.lineStyle(lineThickness, lineColor);
+        let currentY = 0;
+        textMetrics.lines.forEach((line, index) => {
+            let lineMetrics = PIXI.TextMetrics.measureText(line, pixiText.style);
+            let lineY = Math.round(currentY +
+                (lineMetrics.fontProperties.ascent - lineMetrics.fontProperties.descent) * 0.6 +
+                lineMetrics.fontProperties.descent) + lineOffset;
+            let lineX = 0;
+            if (pixiText.style.align === 'center') {
+                lineX = 0 + (pixiText.width - lineMetrics.width) * 0.5;
+            }
+            else if (pixiText.style.align === 'right') {
+                lineX = 0 + pixiText.width - lineMetrics.width;
+            }
+            lineX = Math.floor(lineX);
+            strikethroughGraphics.moveTo(Math.floor(lineX), lineY);
+            strikethroughGraphics.lineTo(Math.floor(lineX + lineMetrics.width), lineY);
+            currentY += lineMetrics.lineHeight;
+        });
+        strikethroughGraphics.endFill();
+        return strikethroughGraphics;
     }
 }
 exports.Text = Text;

package/dist/pixi/game.d.ts

@@ -1,4 +1,4 @@
-import { Variable } from 'actions-lib';
+import { Reducer, Variable } from 'actions-lib';
 import { RGBColor, Vector } from 'helpers-lib';
 import * as PIXI from 'pixi.js';
 import { AssetDefinition, Container } from '.';
@@ -15,6 +15,7 @@ export interface GameConfiguration {
 export declare class Game {
     private static _instance;
     static get instance(): Game;
+    static readonly pause: Reducer<boolean, boolean>;
     private static _camera;
     static get camera(): Camera;
     static get time(): number;

package/dist/pixi/game.js

@@ -37,6 +37,7 @@ class Game {
     static get instance() {
         return this._instance;
     }
+    static { this.pause = actions_lib_1.Reducer.createOr(); }
     static get camera() {
         return this._camera;
     }
@@ -90,6 +91,7 @@ class Game {
             setTimeout(() => this.setScreenSize());
         });
         Game._camera = new camera_1.Camera();
+        // Reminder: If the game should be paused or destroyed, all promises has to be resolved, that relies on update cycle
         this.pixiApp.start();
         this.pixiApp.ticker.add(() => {
             update_cycle_1.UpdateCycle.triggerUpdateTick(this.pixiApp.ticker.deltaMS);

package/dist/utilities/libraries/animator/animator.d.ts

@@ -1,4 +1,4 @@
-import { Destroyable } from '../../../game-entities/base/destroyable';
+import { Attachable } from '../../../game-entities/base/attachable';
 import { AnimatorAnimation } from './animations';
 export interface AnimationState {
     duration: number;
@@ -25,7 +25,7 @@ export interface AnimationOptions {
     reAnimateHandling?: ReAnimateHandlingType;
     completeAnimationsHandling?: CompleteAnimationsHandlingType;
 }
-export declare class Animator<T> extends Destroyable {
+export declare class Animator<T> extends Attachable {
     private target;
     private static animatedObjects;
     private effectOn;
@@ -39,6 +39,7 @@ export declare class Animator<T> extends Destroyable {
     private running;
     private propertyStates;
     private updateCycleSubscription;
+    private allResolvers;
     get isAnimating(): boolean;
     constructor(target: T, effectOn: string | string[], options?: AnimationOptions);
     onChange(callback: (target: T) => void): Animator<T>;

package/dist/utilities/libraries/animator/animator.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Animator = exports.CompleteAnimationsHandlingType = exports.ReAnimateHandlingType = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const destroyable_1 = require("../../../game-entities/base/destroyable");
+const attachable_1 = require("../../../game-entities/base/attachable");
 const update_cycle_1 = require("../../../game-entities/update-cycle");
 const animations_1 = require("./animations");
 var ReAnimateHandlingType;
@@ -22,7 +22,7 @@ const DEFAULT_ANIMATION = new animations_1.AnimationLineer();
 const DEFAULT_LOOP = false;
 const DEFAULT_RE_ANIMATE_HANDLING = ReAnimateHandlingType.throwError;
 const DEFAULT_COMPLETE_ANIMATIONS_HANDLING = CompleteAnimationsHandlingType.stayInCurrentState;
-class Animator extends destroyable_1.Destroyable {
+class Animator extends attachable_1.Attachable {
     static { this.animatedObjects = new Map(); }
     get isAnimating() {
         return this.propertyStates.size > 0;
@@ -33,6 +33,7 @@ class Animator extends destroyable_1.Destroyable {
         this.effectOn = new Set();
         this.running = true;
         this.propertyStates = new Map();
+        this.allResolvers = new Set();
         if (!helpers_lib_1.Comparator.isObject(target)) {
             this.attachToRoot();
             throw new Error(`Animator: target is not an object! Target: "${target}"`);
@@ -93,6 +94,9 @@ class Animator extends destroyable_1.Destroyable {
         if (animatedObjectProperties.size <= 0) {
             Animator.animatedObjects.delete(this.target);
         }
+        this.target = undefined;
+        this.allResolvers.forEach(resolver => resolver());
+        this.allResolvers.clear();
     }
     getAnimationStateOfKey(key) {
         let propertyState = this.propertyStates.get(key);
@@ -155,6 +159,7 @@ class Animator extends destroyable_1.Destroyable {
         });
         this.checkOngoingAnimations(values, options.reAnimateHandling);
         return new Promise(resolveAll => {
+            this.allResolvers.add(resolveAll);
             Promise.all(Object.keys(values).map(key => new Promise(resolve => {
                 let duration = options.duration ?? this.defaultDuration;
                 let animation = options.animation ?? this.defaultAnimation;
@@ -184,9 +189,11 @@ class Animator extends destroyable_1.Destroyable {
                 }
                 catch {
                     resolveAll();
+                    this.allResolvers.delete(resolveAll);
                 }
             }))).then(() => {
                 resolveAll();
+                this.allResolvers.delete(resolveAll);
             });
             this.subscribeUpdateCycle();
         });

package/dist/utilities/libraries/animator/animator.test.js

@@ -330,16 +330,16 @@ decorate_actions_lib_1.ActionsLibDecorator.decorate(ActionsLib);
         });
     });
     (0, vitest_1.describe)('Animation Type Switch', () => {
-        (0, vitest_1.test)('re-animation handling option throw error should throw error', () => {
+        (0, vitest_1.test)('re-animation handling option throw error should throw error', async () => {
             let obj = { x: 0 };
             let animator = new animator_1.Animator(obj, 'x', {
                 duration: 4,
                 reAnimateHandling: animator_1.ReAnimateHandlingType.throwError
             }).attachToRoot();
             animator.animate({ x: 1 });
-            (0, vitest_1.expect)(async () => await animator.animate({ x: 0 })).rejects.toThrow();
+            await (0, vitest_1.expect)(animator.animate({ x: 0 })).rejects.toThrow();
             animator['update'](1);
-            (0, vitest_1.expect)(async () => await animator.animate({ x: 0 })).rejects.toThrow();
+            await (0, vitest_1.expect)(animator.animate({ x: 0 })).rejects.toThrow();
         });
         (0, vitest_1.test)('re-animation handling option ignore should ignore new animation', () => {
             let obj = { x: 0 };
@@ -879,6 +879,15 @@ decorate_actions_lib_1.ActionsLibDecorator.decorate(ActionsLib);
             await game_entities_1.UpdateCycle.triggerUpdateTick(1);
             (0, vitest_1.expect)(obj.x).toEqual(0);
         });
+        (0, vitest_1.test)('destroyed animators animation promises should not get stuck', async () => {
+            return new Promise(done => {
+                let obj = { x: 0 };
+                let animator = new animator_1.Animator(obj, 'x', { duration: 1, animation: new animations_1.AnimationLineer() }).attachToRoot();
+                let promise = animator.animate({ x: 1 });
+                animator.destroy();
+                promise.then(() => done());
+            });
+        });
     });
 });
 //# sourceMappingURL=animator.test.js.map

package/dist/utilities/libraries/animator/state-animation/slide-state-animation.d.ts

@@ -1,10 +1,10 @@
-import { Attachable } from '../../../../game-entities';
+import { AttachmentTarget } from '../../../../game-entities';
 import { StateAnimationOptions } from './state-animation';
 export declare enum SlideStateAnimationState {
     appear = "appear",
     disappear = "disappear"
 }
-export declare class SlideStateAnimation extends Attachable {
+export declare class SlideStateAnimation extends AttachmentTarget {
     private stateAnimation;
     private options;
     private index;

package/dist/utilities/libraries/animator/state-animation/slide-state-animation.js

@@ -11,7 +11,7 @@ var SlideStateAnimationState;
     SlideStateAnimationState["appear"] = "appear";
     SlideStateAnimationState["disappear"] = "disappear";
 })(SlideStateAnimationState || (exports.SlideStateAnimationState = SlideStateAnimationState = {}));
-class SlideStateAnimation extends game_entities_1.Attachable {
+class SlideStateAnimation extends game_entities_1.AttachmentTarget {
     constructor(partialOptions) {
         super();
         this.animationState = 'idle';

package/dist/utilities/libraries/animator/state-animation/state-animation.d.ts

@@ -1,11 +1,11 @@
-import { Attachable } from '../../../../game-entities';
+import { AttachmentTarget } from '../../../../game-entities';
 import { AnimatorAnimation } from '../animations';
 export interface StateAnimationOptions {
     readonly duration: number;
     readonly animation: AnimatorAnimation;
 }
 type AnimationState = 'idle' | 'transitioning' | 'reverting';
-export declare class StateAnimation<T> extends Attachable {
+export declare class StateAnimation<T> extends AttachmentTarget {
     private animator;
     private options;
     private value;

package/dist/utilities/libraries/animator/state-animation/state-animation.js

@@ -5,7 +5,7 @@ const actions_lib_1 = require("actions-lib");
 const game_entities_1 = require("../../../../game-entities");
 const animations_1 = require("../animations");
 const animator_1 = require("../animator");
-class StateAnimation extends game_entities_1.Attachable {
+class StateAnimation extends game_entities_1.AttachmentTarget {
     get currentState() {
         return {
             value: this.value,

package/dist/utilities/libraries/animator/state-animation/visit-disappear-state-animation.d.ts

@@ -1,7 +1,7 @@
-import { Attachable } from '../../../../game-entities';
+import { AttachmentTarget } from '../../../../game-entities';
 import { StateAnimationOptions } from './state-animation';
 type AnimationState = 'hidden' | 'visible' | 'appearing' | 'disappearing' | 'disappearToChange';
-export declare class VisitDisappearStateAnimation<T> extends Attachable {
+export declare class VisitDisappearStateAnimation<T> extends AttachmentTarget {
     private animator;
     private options;
     private value;

package/dist/utilities/libraries/animator/state-animation/visit-disappear-state-animation.js

@@ -5,7 +5,7 @@ const actions_lib_1 = require("actions-lib");
 const game_entities_1 = require("../../../../game-entities");
 const animations_1 = require("../animations");
 const animator_1 = require("../animator");
-class VisitDisappearStateAnimation extends game_entities_1.Attachable {
+class VisitDisappearStateAnimation extends game_entities_1.AttachmentTarget {
     get currentState() {
         return {
             value: this.value,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bard-legends-framework",
-  "version": "0.10.4",
+  "version": "0.10.6",
   "description": "Bard Legends Framework",
   "main": "dist/index.js",
   "files": [
@@ -20,19 +20,12 @@
   "bugs": {
     "url": "https://github.com/sefabaser/Bard-Legends-Framework/issues"
   },
-  "prettier": {
-    "printWidth": 130,
-    "tabWidth": 2,
-    "semicolons": true,
-    "singleQuote": true,
-    "trailingComma": "none",
-    "arrowParens": "avoid"
-  },
   "homepage": "https://github.com/sefabaser/Bard-Legends-Framework#readme",
   "scripts": {
-    "clean-install": "cls && rm -rf node_modules && rm -rf package-lock.json && npm cache clean --force && npm install",
+    "clean-install": "cls && rm -rf node_modules && rm -rf package-lock.json && npm run i",
+    "i": "npm cache clean --force && npm install",
     "pretest": "cls",
-    "test": "vitest",
+    "test": "vitest run",
     "build": "tsc",
     "lint": "biome check . --write --max-diagnostics=1",
     "deploy": "vitest run && npm run build && npm publish",
@@ -54,7 +47,7 @@
     "rollup-plugin-swc": "0.2.1",
     "tslib": "2.6.2",
     "typescript": "5.3.3",
-    "vitest": "1.6.0"
+    "vitest": "3.2.4"
   },
   "types": "dist/index.d.ts"
 }