canvasengine 2.0.0-beta.6 → 2.0.0-beta.61

package/src/components/Text.ts

@@ -1,28 +1,52 @@
+import { layout as layoutPretext, prepare as preparePretext, type PreparedText, type PrepareOptions } from "@chenglou/pretext";
 import { Text as PixiText, TextStyle } from "pixi.js";
-import { createComponent, registerComponent } from "../engine/reactive";
+import { createComponent, registerComponent, Element } from "../engine/reactive";
 import { DisplayObject } from "./DisplayObject";
 import { DisplayObjectProps } from "./types/DisplayObject";
 import { Signal } from "@signe/reactive";
-import { on } from "../engine/trigger";
+import { on, isTrigger } from "../engine/trigger";
+import { Howl } from "howler";
 
 enum TextEffect {
   Typewriter = "typewriter",
 }
 
-interface TextProps extends DisplayObjectProps {
+export interface TextProps extends DisplayObjectProps {
   text?: string;
   style?: Partial<TextStyle>;
   color?: string;
-  size?: string;
+  size?: string | number;
   fontFamily?: string;
   typewriter?: {
     speed?: number;
     start?: () => void;
     onComplete?: () => void;
     skip?: () => void;
+    sound?: {
+      src: string;
+      volume?: number;
+      rate?: number;
+    };
   };
+  context?: any; // Ensure context is available, ideally typed from a base prop or injected
 }
 
+type PretextMeasurement = {
+  width: number;
+  height: number;
+};
+
+const toFiniteNumber = (value: unknown): number | null => {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+};
+
 class CanvasText extends DisplayObject(PixiText) {
   private subscriptionTick: any;
   private fullText: string = "";
@@ -31,10 +55,22 @@ class CanvasText extends DisplayObject(PixiText) {
   private _wordWrapWidth: number = 0;
   private typewriterOptions: any = {};
   private skipSignal?: () => void;
+  private typewriterSound?: Howl;
+  private lastSoundTime: number = 0;
+  private soundDuration: number = 0; // Duration of the sound in milliseconds
+  private pretextPrepared: PreparedText | null = null;
+  private pretextPrepareKey: string = "";
+  private measuredLayout: PretextMeasurement | null = null;
 
-  onMount(args) {
-    super.onMount(args);
-    const { props } = args;
+  /**
+   * Called when the component is mounted to the scene graph.
+   * Initializes the typewriter effect if configured.
+   * @param {Element<CanvasText>} element - The element being mounted with parent and props.
+   * @param {number} [index] - The index of the component among its siblings.
+   */
+  async onMount(element: Element<any>, index?: number): Promise<void> {
+    const { props } = element;
+    await super.onMount(element, index);
     const tick: Signal = props.context.tick;
 
     if (props.text && props.typewriter) {
@@ -44,12 +80,18 @@ class CanvasText extends DisplayObject(PixiText) {
       // Set typewriter options
       if (props.typewriter) {
         this.typewriterOptions = props.typewriter;
-        if (this.typewriterOptions.skip) {
+        if (this.typewriterOptions.skip && isTrigger(this.typewriterOptions.skip)) {
           on(this.typewriterOptions.skip, () => {
             this.skipTypewriter();
           });
         }
+        // Initialize typewriter sound if configured
+        if (this.typewriterOptions.sound) {
+          this.initializeTypewriterSound();
+        }
       }
+      // Update layout after initializing typewriter
+      this.updateLayout();
     }
     this.subscriptionTick = tick.observable.subscribe(() => {
       if (props.typewriter) {
@@ -63,23 +105,24 @@ class CanvasText extends DisplayObject(PixiText) {
     if (props.typewriter) {
       if (props.typewriter) {
         this.typewriterOptions = props.typewriter;
+        // Reinitialize sound if sound configuration changed
+        if (props.typewriter.sound) {
+          this.initializeTypewriterSound();
+        }
       }
     }
-    if (props.text) {
-      this.text = props.text;
+    if (props.text !== undefined) {
+      this.text = ''+props.text;
     }
     if (props.text !== undefined && props.text !== this.fullText && this.fullProps.typewriter) {
       this.text = "";
       this.currentIndex = 0;
       this.fullText = props.text;
+      // Update layout after resetting typewriter
+      this.updateLayout();
     }
     if (props.style) {
-      for (const key in props.style) {
-        this.style[key] = props.style[key];
-      }
-      if (props.style.wordWrapWidth) {
-        this._wordWrapWidth = props.style.wordWrapWidth;
-      }
+      this.applyTextStyle(props.style);
     }
     if (props.color) {
       this.style.fill = props.color;
@@ -90,18 +133,186 @@ class CanvasText extends DisplayObject(PixiText) {
     if (props.fontFamily) {
       this.style.fontFamily = props.fontFamily;
     }
-    if (this._wordWrapWidth) {
-      this.setWidth(this._wordWrapWidth);
-    } else {
-      this.setWidth(this.width);
-    }
-    this.setHeight(this.height);
+    this.updateWordWrapWidth();
+    
+    // Use the centralized layout update method
+    this.updateLayout();
   }
 
   get onCompleteCallback() {
     return this.typewriterOptions.onComplete;
   }
 
+  /**
+   * Initializes the typewriter sound effect using Howler.
+   * Creates a Howl instance with the configured sound settings.
+   * Calculates the sound duration to prevent overlapping sounds.
+   */
+  private initializeTypewriterSound() {
+    if (!this.typewriterOptions.sound?.src) return;
+    
+    this.typewriterSound = new Howl({
+      src: [this.typewriterOptions.sound.src],
+      volume: this.typewriterOptions.sound.volume ?? 0.5,
+      rate: this.typewriterOptions.sound.rate ?? 1.0,
+      preload: true,
+      onload: () => {
+        // Calculate sound duration in milliseconds
+        if (this.typewriterSound) {
+          const duration = this.typewriterSound.duration();
+          const rate = this.typewriterOptions.sound?.rate ?? 1.0;
+          this.soundDuration = (duration / rate) * 1000;
+        }
+      }
+    });
+  }
+
+  /**
+   * Plays the typewriter sound with duration-based cooldown to prevent overlapping sounds.
+   * @param {number} currentTime - The current timestamp to check against sound duration.
+   */
+  private playTypewriterSound(currentTime: number) {
+    if (!this.typewriterSound || !this.typewriterOptions.sound) return;
+    
+    // Check if enough time has passed since the last sound play
+    // Use the actual sound duration to prevent overlap
+    if (this.soundDuration > 0 && currentTime - this.lastSoundTime < this.soundDuration) return;
+    
+    this.typewriterSound.play();
+    this.lastSoundTime = currentTime;
+  }
+
+  /**
+   * Updates the layout properties of the text component.
+   * This method ensures consistent width, height and word wrap behavior.
+   */
+  private updateLayout() {
+    const measured = this.measurePretextLayout();
+    const width = measured?.width ?? this.width;
+    const height = measured?.height ?? this.height;
+
+    this.measuredLayout = measured ?? { width, height };
+    this.setMeasuredLayout(width, height);
+  }
+
+  private applyTextStyle(style: Partial<TextStyle>) {
+    const assign = (this.style as TextStyle & { assign?: (values: any) => TextStyle }).assign;
+    if (typeof assign === "function") {
+      assign.call(this.style, style);
+      return;
+    }
+
+    for (const key in style) {
+      (this.style as any)[key] = (style as any)[key];
+    }
+  }
+
+  private updateWordWrapWidth() {
+    if (!this.style.wordWrap) {
+      this._wordWrapWidth = 0;
+      return;
+    }
+    const wordWrapWidth = toFiniteNumber(this.style.wordWrapWidth);
+    this._wordWrapWidth = wordWrapWidth !== null && wordWrapWidth > 0 ? wordWrapWidth : 0;
+  }
+
+  private measurePretextLayout(): PretextMeasurement | null {
+    if (!this.style.wordWrap || this._wordWrapWidth <= 0) {
+      this.pretextPrepared = null;
+      this.pretextPrepareKey = "";
+      return null;
+    }
+
+    const text = `${this.text ?? ""}`;
+    const font = this.resolvePretextFont();
+    const lineHeight = this.resolveLineHeight();
+    const options = this.resolvePretextOptions();
+    const prepareKey = JSON.stringify([text, font, options.whiteSpace, options.wordBreak, options.letterSpacing]);
+
+    try {
+      if (this.pretextPrepareKey !== prepareKey || !this.pretextPrepared) {
+        this.pretextPrepared = preparePretext(text, font, options);
+        this.pretextPrepareKey = prepareKey;
+      }
+
+      const result = layoutPretext(this.pretextPrepared, this._wordWrapWidth, lineHeight);
+      return {
+        width: this._wordWrapWidth,
+        height: result.height,
+      };
+    } catch {
+      this.pretextPrepared = null;
+      this.pretextPrepareKey = "";
+      return null;
+    }
+  }
+
+  private resolvePretextFont(): string {
+    const fontString = (this.style as TextStyle & { _fontString?: string })._fontString;
+    if (fontString) return fontString;
+
+    const fontSize = this.resolveFontSize();
+    const fontFamily = Array.isArray(this.style.fontFamily)
+      ? this.style.fontFamily.join(",")
+      : this.style.fontFamily;
+
+    return `${this.style.fontStyle} ${this.style.fontVariant} ${this.style.fontWeight} ${fontSize}px ${fontFamily}`;
+  }
+
+  private resolvePretextOptions(): PrepareOptions {
+    return {
+      whiteSpace: this.style.whiteSpace === "normal" ? "normal" : "pre-wrap",
+      letterSpacing: this.style.letterSpacing || undefined,
+    };
+  }
+
+  private resolveLineHeight(): number {
+    const lineHeight = toFiniteNumber(this.style.lineHeight);
+    if (lineHeight !== null && lineHeight > 0) return lineHeight;
+    return this.resolveFontSize();
+  }
+
+  private resolveFontSize(): number {
+    const fontSize = toFiniteNumber(this.style.fontSize);
+    return fontSize !== null && fontSize > 0 ? fontSize : 16;
+  }
+
+  private setMeasuredLayout(width: number, height: number) {
+    const layout: { width?: number; height?: number } = {};
+
+    if (this.fullProps.width === undefined) {
+      this.displayWidth.set(width);
+      if (this.parentIsFlex) {
+        layout.width = width;
+      }
+    }
+
+    if (this.fullProps.height === undefined) {
+      this.displayHeight.set(height);
+      if (this.parentIsFlex) {
+        layout.height = height;
+      }
+    }
+
+    if (this.parentIsFlex && (layout.width !== undefined || layout.height !== undefined)) {
+      (this as any).layout = layout;
+    }
+  }
+
+  getWidth(): number {
+    if (this.fullProps.width === undefined && this.measuredLayout) {
+      return this.measuredLayout.width;
+    }
+    return super.getWidth();
+  }
+
+  getHeight(): number {
+    if (this.fullProps.height === undefined && this.measuredLayout) {
+      return this.measuredLayout.height;
+    }
+    return super.getHeight();
+  }
+
   private typewriterEffect() {
     if (this.currentIndex < this.fullText.length) {
       const nextIndex = Math.min(
@@ -111,6 +322,14 @@ class CanvasText extends DisplayObject(PixiText) {
       this.text = this.fullText.slice(0, nextIndex);
       this.currentIndex = nextIndex;
 
+      // Play typewriter sound if configured
+      if (this.typewriterOptions.sound) {
+        this.playTypewriterSound(Date.now());
+      }
+
+      // Update layout after text change to maintain proper word wrap and dimensions
+      this.updateLayout();
+
       // Check if typewriter effect is complete
       if (
         this.currentIndex === this.fullText.length &&
@@ -128,15 +347,40 @@ class CanvasText extends DisplayObject(PixiText) {
     }
     this.text = this.fullText;
     this.currentIndex = this.fullText.length;
+    
+    // Update layout after setting full text to maintain proper word wrap and dimensions
+    this.updateLayout();
   }
 
-  onDestroy(): void {
-    super.onDestroy();
-    this.subscriptionTick.unsubscribe();
+  /**
+   * Called when the component is about to be destroyed.
+   * Unsubscribes from the tick observable and cleans up sound resources.
+   * @param {Element<any>} parent - The parent element.
+   * @param {() => void} [afterDestroy] - An optional callback function to be executed after the component's own destruction logic.
+   */
+  async onDestroy(parent: Element<any>, afterDestroy?: () => void): Promise<void> {
+    const _afterDestroy = async () => {
+      if (this.subscriptionTick) {
+        this.subscriptionTick.unsubscribe();
+      }
+      // Clean up typewriter sound
+      if (this.typewriterSound) {
+        this.typewriterSound.stop();
+        this.typewriterSound.unload();
+        this.typewriterSound = undefined;
+      }
+      this.pretextPrepared = null;
+      this.pretextPrepareKey = "";
+      this.measuredLayout = null;
+      if (afterDestroy) {
+        afterDestroy();
+      }
+    }
+    await super.onDestroy(parent, _afterDestroy);
   }
 }
 
-interface CanvasText extends PixiText {}
+// interface CanvasText extends PixiText {} // Removed as it's redundant and causes type conflicts
 
 registerComponent("Text", CanvasText);
 

package/src/components/Viewport.ts

@@ -1,8 +1,9 @@
 import { Viewport as PixiViewport } from 'pixi-viewport';
 import { Subscription } from 'rxjs';
-import { createComponent, registerComponent } from '../engine/reactive';
-import { DisplayObject } from './DisplayObject';
-import { effect } from '@signe/reactive';
+import { createComponent, registerComponent, Element, Props } from '../engine/reactive';
+import { DisplayObject, ComponentInstance } from './DisplayObject';
+import { effect, Signal } from '@signe/reactive';
+import { Graphics, Container, ContainerChild, IRenderLayer } from 'pixi.js';
 
 const EVENTS = [
     'bounce-x-end',
@@ -28,55 +29,103 @@ const EVENTS = [
     'zoomed-end'
 ]
 
-export class CanvasViewport extends DisplayObject(PixiViewport) {
+export interface ViewportProps extends Props {
+    screenWidth?: number;
+    screenHeight?: number;
+    worldWidth?: number;
+    worldHeight?: number;
+    sortableChildren?: boolean;
+    clamp?: boolean | {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    };
+    context?: any;
+    [key: string]: any;
+}
+
+export class CanvasViewport extends DisplayObject(Container) {
     private tickSubscription: Subscription
     overrideProps = ['wheel']
+    #mask: Graphics
+    public viewport: PixiViewport
 
     constructor() {
+        super()
         const defaultOptions = {
             noTicker: true,
             events: {
                 domElement: {
-                    addEventListener: () => {}
+                    addEventListener: () => { }
                 }
             },
         }
         // @ts-ignore
-        super(defaultOptions) 
+        this.viewport = new PixiViewport(defaultOptions)
+        super.addChild(this.viewport)
+
+        this.#mask = new Graphics()
+        super.addChild(this.#mask)
+        this.mask = this.#mask
+    }
+
+    addChild<U extends any[]>(...children: U): U[0] {
+        return this.viewport.addChild(...children)
+    }
+
+    addChildAt<T extends ContainerChild | IRenderLayer>(child: T, index: number): T {
+        return this.viewport.addChildAt(child, index) as T
     }
 
     onInit(props) {
         super.onInit(props)
         for (let event of EVENTS) {
-            const camelCaseEvent = event.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
-            if (props[camelCaseEvent]) {
-                this.on(event, props[camelCaseEvent])
-            }
+            if (props[event]) this.viewport.on(event, props[event])
         }
     }
 
-    onMount(element) {
-        super.onMount(element)
-        const { tick, renderer, canvasSize } = element.props.context
-        let isDragging = false
-        
+    /**
+     * Called when the component is mounted to the scene graph.
+     * Initializes viewport settings and subscriptions.
+     * @param {Element<CanvasViewport>} element - The element being mounted. Its `props` property (of type ViewportProps) contains component properties and context.
+     * @param {number} [index] - The index of the component among its siblings.
+     */
+    async onMount(element: Element<any>, index?: number): Promise<void> {
+        element.props.context.viewport = this.viewport
+        await super.onMount(element, index);
+        const { props } = element;
+        const { tick, app, canvasSize } = props.context;
+
         effect(() => {
-            this.screenWidth = canvasSize().width
-            this.screenHeight = canvasSize().height
+            if (props.screenWidth === undefined) {
+                this.viewport.screenWidth = canvasSize().width
+            }
+            if (props.screenHeight === undefined) {
+                this.viewport.screenHeight = canvasSize().height
+            }
+            this.updateMask()
+        })
+
+        effect(() => {
+            const _app = app()
+            if (!_app) return
+
+            const renderer = _app.renderer
+
+            renderer.events.domElement.addEventListener(
+                'wheel',
+                this.viewport.input.wheelFunction
+            );
+
+            this.viewport.options.events = renderer.events
         })
 
-        renderer.events.domElement.addEventListener(
-            'wheel',
-            this.input.wheelFunction
-        );
-        this.options.events = renderer.events
- 
         this.tickSubscription = tick.observable.subscribe(({ value }) => {
-            this.update(value.timestamp)
+            this.viewport.update(value.deltaTime)
         })
 
-        element.props.context.viewport = this
-        this.updateViewportSettings(element.props)
+        this.updateViewportSettings(props)
     }
 
     onUpdate(props) {
@@ -86,74 +135,84 @@ export class CanvasViewport extends DisplayObject(PixiViewport) {
 
     private updateViewportSettings(props) {
         if (props.screenWidth !== undefined) {
-            this.screenWidth = props.screenWidth
+            this.viewport.screenWidth = props.screenWidth
         }
         if (props.screenHeight !== undefined) {
-            this.screenHeight = props.screenHeight
+            this.viewport.screenHeight = props.screenHeight
         }
+        this.updateMask()
         if (props.worldWidth !== undefined) {
-            this.worldWidth = props.worldWidth
+            this.viewport.worldWidth = props.worldWidth
         }
         if (props.worldHeight !== undefined) {
-            this.worldHeight = props.worldHeight
+            this.viewport.worldHeight = props.worldHeight
+        }
+        if (props.sortableChildren !== undefined) {
+            this.viewport.sortableChildren = props.sortableChildren
+        }
+        if (props.drag) {
+            this.viewport.drag(props.drag)
         }
-        // if (props.drag) {
-        //     if (props.drag === true) {
-                
-        //     } else {
-        //         this.drag(props.drag)
-        //     }
-        // }
         if (props.clamp) {
-            this.clamp(props.clamp)
+            this.viewport.clamp(props.clamp.value ?? props.clamp)
         }
         if (props.wheel) {
             if (props.wheel === true) {
-                this.wheel()
+                this.viewport.wheel()
             } else {
-                this.wheel(props.wheel)
+                this.viewport.wheel(props.wheel)
             }
         }
         if (props.decelerate) {
             if (props.decelerate === true) {
-                this.decelerate()
+                this.viewport.decelerate()
             } else {
-                this.decelerate(props.decelerate)
+                this.viewport.decelerate(props.decelerate)
             }
         }
         if (props.pinch) {
             if (props.pinch === true) {
-                this.pinch()
+                this.viewport.pinch()
             } else {
-                this.pinch(props.pinch)
+                this.viewport.pinch(props.pinch)
             }
         }
     }
 
-    onDestroy(): void {
-        super.onDestroy()
-        this.tickSubscription.unsubscribe()
+    private updateMask() {
+        if (!this.#mask) return
+        this.#mask.clear()
+        this.#mask.beginFill(0xffffff)
+        this.#mask.drawRect(0, 0, this.viewport.screenWidth, this.viewport.screenHeight)
+        this.#mask.endFill()
     }
-}
 
-export interface CanvasViewport extends PixiViewport { }
+    /**
+     * Called when the component is about to be destroyed.
+     * Unsubscribes from the tick observable.
+     * @param {Element<any>} parent - The parent element.
+     * @param {() => void} [afterDestroy] - An optional callback function to be executed after the component's own destruction logic.
+     */
+    async onDestroy(parent: Element<any>, afterDestroy?: () => void): Promise<void> {
+        const _afterDestroy = async () => {
+            this.tickSubscription.unsubscribe()
+            afterDestroy()
+        }
+        await super.onDestroy(parent, _afterDestroy);
+    }
 
-registerComponent('Viewport', CanvasViewport)
+    // Proxy methods for viewport plugins
+    follow(...args: any[]) {
+        return (this.viewport.follow as any)(...args)
+    }
 
-export interface ViewportProps {
-    screenWidth?: number;
-    screenHeight?: number;
-    worldWidth?: number;
-    worldHeight?: number;
-    clamp?: boolean | {
-        left?: number;
-        right?: number;
-        top?: number;
-        bottom?: number;
-    };
-    [key: string]: any;
+    get plugins() {
+        return this.viewport.plugins
+    }
 }
 
+registerComponent('Viewport', CanvasViewport)
+
 export function Viewport(props: ViewportProps) {
     return createComponent('Viewport', props);
-}
+}

package/src/components/index.ts

@@ -1,6 +1,7 @@
 export { Canvas } from './Canvas'
 export { Container } from './Container'
-export { Graphics, Rect, Circle, Ellipse, Triangle, Svg as svg } from './Graphic'
+export { Graphics, Rect, Circle, Ellipse, Triangle, Svg } from './Graphic'
+export { Mesh } from './Mesh'
 export { Scene } from './Scene'
 export { ParticlesEmitter } from './ParticleEmitter'
 export { Sprite } from './Sprite'
@@ -9,4 +10,10 @@ export { Text } from './Text'
 export { TilingSprite } from './TilingSprite'
 export { Viewport } from './Viewport'
 export { NineSliceSprite } from './NineSliceSprite'
-export { type ComponentInstance } from './DisplayObject'
+export { type ComponentInstance } from './DisplayObject'
+export { DOMContainer } from './DOMContainer'
+export { DOMElement } from './DOMElement'
+export { DOMSprite } from './DOMSprite'
+export { Button, ButtonState, type ButtonProps, type ButtonStyle } from './Button'
+export { Joystick, type JoystickSettings } from './Joystick'
+export { FocusContainer, Navigation, type FocusContainerProps } from './FocusContainer'