canvasengine 2.0.0-beta.4 → 2.0.0-beta.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canvasengine",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.5",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/components/Graphic.ts

@@ -37,7 +37,7 @@ interface SvgProps extends DisplayObjectProps {
 }
 
 class CanvasGraphics extends DisplayObject(PixiGraphics) {
-  onInit(props: GraphicsProps) {
+  onInit(props) {
     super.onInit(props);
     if (props.draw) {
       effect(() => {

package/src/components/Sprite.ts

@@ -227,6 +227,24 @@ export class CanvasSprite extends DisplayObject(PixiSprite) {
   async onUpdate(props) {
     super.onUpdate(props);
 
+    const setTexture = async (image: string) => {
+      const onProgress = this.fullProps.loader?.onProgress;
+      const texture = await Assets.load(image, (progress) => {
+        if (onProgress) onProgress(progress);
+        if (progress == 1) {
+          const onComplete = this.fullProps.loader?.onComplete;
+          if (onComplete) {
+            // hack to memoize the texture
+            setTimeout(() => {
+              onComplete(texture);
+            });
+          }
+        }
+      });
+
+      return texture
+    }
+
     const sheet = props.sheet;
     if (sheet?.params) this.sheetParams = sheet?.params;
 
@@ -239,14 +257,13 @@ export class CanvasSprite extends DisplayObject(PixiSprite) {
 
     if (props.scaleMode) this.baseTexture.scaleMode = props.scaleMode;
     else if (props.image && this.fullProps.rectangle === undefined) {
-      this.texture = await Assets.load(this.fullProps.image);
+      this.texture = await setTexture(this.fullProps.image);
     } else if (props.texture) {
       this.texture = props.texture;
     }
-
     if (props.rectangle !== undefined) {
       const { x, y, width, height } = props.rectangle?.value ?? props.rectangle;
-      const texture = await Assets.load(this.fullProps.image);
+      const texture = await setTexture(this.fullProps.image);
       this.texture = new Texture({
         source: texture.source,
         frame: new Rectangle(x, y, width, height),
@@ -483,6 +500,10 @@ export interface SpritePropsWithSheet
     params?: any;
     onFinish?: () => void;
   };
+  loader?: {
+    onProgress?: (progress: number) => void;
+    onComplete?: (texture: Texture) => void;
+  };
 }
 
 export type SpritePropTypes = SpritePropsWithImage | SpritePropsWithSheet;

package/src/components/Video.ts

@@ -0,0 +1,110 @@
+import { Texture } from "pixi.js";
+import { h, mount } from "../engine/signal";
+import { useDefineProps } from "../hooks/useProps";
+import { Sprite } from "./Sprite";
+import { effect, Signal, signal } from "@signe/reactive";
+
+interface VideoProps {
+    source: string;
+    paused?: boolean;
+    loop?: boolean;
+    muted?: boolean;
+    loader?: {
+        onComplete?: (texture: Texture) => void;
+        onProgress?: (progress: number) => void;
+    };
+}
+
+export function Video(props: VideoProps) {
+    const eventsMap = {
+        audioprocess: null,
+        canplay: null,
+        canplaythrough: null,
+        complete: null,
+        durationchange: null,
+        emptied: null,
+        ended: null,
+        loadeddata: null,
+        loadedmetadata: null,
+        pause: null,
+        play: null,
+        playing: null,
+        progress: null,
+        ratechange: null,
+        seeked: null,
+        seeking: null,
+        stalled: null,
+        suspend: null,
+        timeupdate: null,
+        volumechange: null,
+        waiting: null
+    }
+
+    const video: Signal<HTMLVideoElement | null> = signal(null)
+    const defineProps = useDefineProps(props)
+    const { play, loop, muted } = defineProps({
+        play: {
+            type: Boolean,
+            default: true
+        },
+        loop: {
+            type: Boolean,
+            default: false
+        },
+        muted: {
+            type: Boolean,
+            default: false
+        }
+    })
+
+    effect(() => {
+        const _video = video()
+        const state = play()
+        if (_video && state !== undefined) {
+            if (state) {
+                _video.play()
+            } else {
+                _video.pause()
+            }
+        }
+        if (_video && loop()) {
+            _video.loop = loop()
+        }
+        if (_video && muted()) {
+            _video.muted = muted()
+        }
+    })
+
+    mount(() => {
+        return () => {
+            for (let event in eventsMap) {
+                if (eventsMap[event]) {
+                    video().removeEventListener(event, eventsMap[event])
+                }
+            }
+        }
+    })
+
+    return h(Sprite, {
+        ...props,
+        image: props.source,
+        loader: {
+            onComplete: (texture) => {
+                const source = texture.source.resource
+                video.set(source)
+                if (props?.loader?.onComplete) {
+                    props.loader.onComplete(texture)
+                }
+                for (let event in eventsMap) {
+                    if (props[event]) {
+                        const cb = (ev) => {
+                            props[event](ev)
+                        }
+                        eventsMap[event] = cb
+                        source.addEventListener(event, cb)
+                    }
+                }
+            }
+        }
+    })
+}

package/src/components/index.ts

@@ -4,6 +4,7 @@ export { Graphics, Rect, Circle, Ellipse, Triangle, Svg as svg } from './Graphic
 export { Scene } from './Scene'
 export { ParticlesEmitter } from './ParticleEmitter'
 export { Sprite } from './Sprite'
+export { Video } from './Video'
 export { Text } from './Text'
 export { TilingSprite } from './TilingSprite'
 export { Viewport } from './Viewport'

package/src/engine/reactive.ts

@@ -182,9 +182,24 @@ export function createComponent(tag: string, props?: Props): Element {
   }
 
   instance.onInit?.(element.props);
-  instance.onUpdate?.(element.props);
 
-  const onMount = (parent: Element, element: Element, index?: number) => {
+  const elementsListen = new Subject<any>()
+
+  if (props?.isRoot) {
+    element.allElements = elementsListen
+    element.props.context.rootElement = element;
+    element.componentInstance.onMount?.(element);
+    propagateContext(element);
+  }
+
+  if (props) {
+    for (let key in props) {
+      const directive = applyDirective(element, key);
+      if (directive) element.directives[key] = directive;
+    }
+  }
+
+  function onMount(parent: Element, element: Element, index?: number) {
     element.props.context = parent.props.context;
     element.parent = parent;
     element.componentInstance.onMount?.(element, index);
@@ -196,85 +211,79 @@ export function createComponent(tag: string, props?: Props): Element {
     });
   };
 
-  const elementsListen = new Subject<any>()
-
-  if (props?.isRoot) {
-    // propagate recrusively context in all children
-    const propagateContext = async (element) => {
-      if (element.props.attach) {
-        const isReactiveAttach = isSignal(element.propObservables?.attach)
-        if (!isReactiveAttach) {
-          element.props.children.push(element.props.attach)
-        }
-        else {
-          let lastElement = null
-          element.propObservables.attach.observable.subscribe(({ value, type }) => {
-            if (type != "init") {
-              destroyElement(lastElement)
-            }
-            lastElement = value
-            onMount(element, value);
-            propagateContext(value);
-          })
-        }
+  async function propagateContext(element) {
+    if (element.props.attach) {
+      const isReactiveAttach = isSignal(element.propObservables?.attach)
+      if (!isReactiveAttach) {
+        element.props.children.push(element.props.attach)
       }
-      if (!element.props.children) {
-        return;
-      }
-      for (let child of element.props.children) {
-        if (!child) continue;
-        if (isPromise(child)) {
-          child = await child;
-        }
-        if (child instanceof Observable) {
-          child.subscribe(
-            ({
-              elements: comp,
-              prev,
-            }: {
-              elements: Element[];
-              prev?: Element;
-            }) => {
-              // if prev, insert element after this
-              const components = comp.filter((c) => c !== null);
-              if (prev) {
-                components.forEach((c) => {
-                  const index = element.props.children.indexOf(prev.props.key);
-                  onMount(element, c, index + 1);
-                  propagateContext(c);
-                });
-                return;
-              }
-              components.forEach((component) => {
-                if (!Array.isArray(component)) {
-                  onMount(element, component);
-                  propagateContext(component);
-                } else {
-                  component.forEach((comp) => {
-                    onMount(element, comp);
-                    propagateContext(comp);
-                  });
+      else {
+        await new Promise((resolve) => {
+            let lastElement = null
+            element.propSubscriptions.push(element.propObservables.attach.observable.subscribe(async (args) => {
+                const value = args?.value ?? args
+                if (!value) {
+                  throw new Error(`attach in ${element.tag} is undefined or null, add a component`)
                 }
+                if (lastElement) {
+                  destroyElement(lastElement)
+                }
+                lastElement = value
+                await createElement(element, value)
+                resolve(undefined)
+            }))
+        })
+      }
+    }
+    if (!element.props.children) {
+      return;
+    }
+    for (let child of element.props.children) {
+      if (!child) continue;
+      await createElement(element, child)
+    }
+  };
+
+  async function createElement(parent: Element, child: Element) {
+    if (isPromise(child)) {
+      child = await child;
+    }
+    if (child instanceof Observable) {
+      child.subscribe(
+        ({
+          elements: comp,
+          prev,
+        }: {
+          elements: Element[];
+          prev?: Element;
+        }) => {
+          // if prev, insert element after this
+          const components = comp.filter((c) => c !== null);
+          if (prev) {
+            components.forEach((c) => {
+              const index = parent.props.children.indexOf(prev.props.key);
+              onMount(parent, c, index + 1);
+              propagateContext(c);
+            });
+            return;
+          }
+          components.forEach((component) => {
+            if (!Array.isArray(component)) {
+              onMount(parent, component);
+              propagateContext(component);
+            } else {
+              component.forEach((comp) => {
+                onMount(parent, comp);
+                propagateContext(comp);
               });
-              elementsListen.next(undefined)
             }
-          );
-        } else {
-          onMount(element, child);
-          await propagateContext(child);
+          });
+          elementsListen.next(undefined)
         }
-      }
-    };
-    element.allElements = elementsListen
-    element.props.context.rootElement = element;
-    element.componentInstance.onMount?.(element);
-    propagateContext(element);
-  }
-
-  if (props) {
-    for (let key in props) {
-      const directive = applyDirective(element, key);
-      if (directive) element.directives[key] = directive;
+      );
+    } else {
+      onMount(parent, child);
+      await propagateContext(child);
     }
   }
 

package/testing/index.ts

@@ -0,0 +1,11 @@
+import { bootstrapCanvas, Canvas, ComponentInstance, Element, h } from "canvasengine";
+
+export class TestBed {
+    static async createComponent(component: any, props: any = {}, children: any = []): Promise<Element<ComponentInstance>> {
+        const comp = () => h(Canvas, {
+            tickStart: false
+        }, h(component, props, children))
+        const canvas = await bootstrapCanvas(document.getElementById('root'), comp)
+        return canvas.props.children?.[0]
+    }
+}