canvasengine 2.0.0-beta.3 → 2.0.0-beta.30

package/src/engine/signal.ts

@@ -3,6 +3,7 @@ import {
 } from "rxjs";
 import type { Element } from "./reactive";
 import { Tick } from "../directives/Scheduler";
+import { Container } from "../components";
 
 type MountFunction = (fn: (element: Element) => void) => void;
 
@@ -91,7 +92,7 @@ export function tick(fn: (tickValue: Tick, element: Element) => void) {
  * ```
  */
 export function h<C extends ComponentFunction<any>>(
-  componentFunction: C,
+  componentFunction: C | Element,
   props: Parameters<C>[0] = {} as Parameters<C>[0],
   ...children: any[]
 ): ReturnType<C> {
@@ -110,7 +111,22 @@ export function h<C extends ComponentFunction<any>>(
     children = children[0]
   }
 
-  let component = componentFunction({ ...props, children }) as Element;
+  let component: Element
+
+  if (Array.isArray(componentFunction)) {
+    if (componentFunction.length === 1) {
+      component = componentFunction[0]
+    }
+    else {
+      component = h(Container, {}, ...componentFunction) as Element
+    }
+  }
+  else if ('tag' in componentFunction) {
+    component = componentFunction
+  }
+  else {
+    component = componentFunction({ ...props, children }) as Element;
+  }
 
   if (!component) {
     component = {} as any

package/src/engine/trigger.ts

@@ -2,39 +2,95 @@ import { effect, signal } from "@signe/reactive";
 
 interface Listen<T = any> {
   config: T | undefined;
-  seed: number;
+  seed: {
+    config: T | undefined;
+    value: number;
+    resolve: (value: any) => void;
+  };
 }
 
 interface Trigger<T = any> {
-  start: () => void;
+  start: () => Promise<void>;
   listen: () => Listen<T> | undefined;
 }
 
+/**
+ * Checks if the given argument is a Trigger object
+ * @param arg - The value to check
+ * @returns True if the argument is a Trigger object
+ */
 export function isTrigger(arg: any): arg is Trigger<any> {
   return arg?.start && arg?.listen;
 }
 
-export function trigger<T = any>(config?: T): Trigger<T> {
-  const _signal = signal(0);
+/**
+ * Creates a new trigger that can be used to pass data between components
+ * @param globalConfig - Optional configuration data to be passed when the trigger is activated
+ * @returns A Trigger object with start and listen methods
+ * @example
+ * ```ts
+ * const myTrigger = trigger()
+ * 
+ * on(myTrigger, (data) => {
+ *   console.log('Triggered with data:', data)
+ * })
+ * 
+ * myTrigger.start({ message: 'Hello' })
+ * ```
+ */
+export function trigger<T = any>(globalConfig?: T): Trigger<T> {
+  const _signal = signal({
+    config: globalConfig,
+    value: 0,
+    resolve: (value: any) => void 0,
+  });
   return {
-    start: () => {
-      _signal.set(Math.random());
+    start: (config?: T) => {
+      return new Promise((resolve: (value: any) => void) => {
+        _signal.set({
+          config: {
+            ...globalConfig,
+            ...config,
+          },
+          resolve,
+          value: Math.random(),
+        });
+      });
     },
     listen: (): Listen<T> | undefined => {
       return {
-        config,
+        config: globalConfig,
         seed: _signal(),
       };
     },
   };
 }
 
-export function on(triggerSignal: any, callback: (config: any) => void) {
+/**
+ * Subscribes to a trigger and executes a callback when the trigger is activated
+ * @param triggerSignal - The trigger to subscribe to
+ * @param callback - Function to execute when the trigger is activated
+ * @throws Error if triggerSignal is not a valid trigger
+ * @example
+ * ```ts
+ * const click = trigger()
+ * 
+ * on(click, () => {
+ *   console.log('Click triggered')
+ * })
+ * ```
+ */
+export function on(triggerSignal: any, callback: (config: any) => void | Promise<void>) {
   if (!isTrigger(triggerSignal)) {
     throw new Error("In 'on(arg)' must have a trigger signal type");
   }
   effect(() => {
     const result = triggerSignal.listen();
-    if (result?.seed) callback(result.config);
+    if (result?.seed.value) {
+      const ret = callback(result?.seed.config);
+      if (ret && typeof ret.then === 'function') {
+        ret.then(result?.seed.resolve);
+      }
+    }
   });
 }

package/src/engine/utils.ts

@@ -1,17 +1,36 @@
 import { ObservablePoint } from "pixi.js"
+import { Observable } from "rxjs"
 
+/**
+ * Checks if code is running in a browser environment
+ * @returns {boolean} True if running in browser, false otherwise
+ */
 export function isBrowser(): boolean {
     return typeof window !== 'undefined'
 }
 
+/**
+ * Returns current high-resolution timestamp
+ * @returns {number} Current time in milliseconds
+ */
 export function preciseNow(): number {
     return typeof performance !== 'undefined' ? performance.now() : Date.now()
 }
 
+/**
+ * Converts frames per second to milliseconds
+ * @param {number} fps - Frames per second
+ * @returns {number} Milliseconds per frame
+ */
 export function fps2ms(fps: number): number {
     return 1000 / fps
 }
 
+/**
+ * Checks if a value is a Promise
+ * @param {any} value - Value to check
+ * @returns {boolean} True if value is a Promise, false otherwise
+ */
 export function isPromise(value: any): boolean {
     return value && value instanceof Promise
 }
@@ -58,15 +77,49 @@ function deepEquals(a: any, b: any): boolean {
     return false;
 }
 
+/**
+ * Checks if a value is a function
+ * @param {unknown} val - Value to check
+ * @returns {boolean} True if value is a function, false otherwise
+ */
 export function isFunction(val: unknown): boolean {
     return {}.toString.call(val) === '[object Function]'
 }
 
+/**
+ * Checks if a value is a plain object (not an instance of a class)
+ * @param {unknown} val - Value to check
+ * @returns {boolean} True if value is a plain object (not null, not array, not instance), false otherwise
+ * @example
+ * ```ts
+ * isObject({}) // true
+ * isObject(new Date()) // false
+ * isObject([]) // false
+ * isObject(null) // false
+ * ```
+ */
 export function isObject(val: unknown): boolean {
-    return typeof val == 'object' && val != null && !Array.isArray(val)
+    return typeof val == 'object' && val != null && !Array.isArray(val) && val.constructor === Object
 }
 
-export function set(obj, path, value, onlyPlainObject = false) {
+export function isObservable(val: unknown): boolean {
+    return val instanceof Observable
+}
+
+/**
+ * Sets a value in an object using a dot notation path
+ * @param {Record<string, any>} obj - Target object
+ * @param {string | string[]} path - Path to set value at (e.g., 'a.b.c' or ['a', 'b', 'c'])
+ * @param {any} value - Value to set
+ * @param {boolean} onlyPlainObject - If true, only creates plain objects in path
+ * @returns {Record<string, any>} Modified object
+ */
+export function set(
+    obj: Record<string, any>, 
+    path: string | string[], 
+    value: any, 
+    onlyPlainObject = false
+): Record<string, any> {
     if (Object(obj) !== obj) return obj;
 
     if (typeof path === 'string') {
@@ -79,8 +132,8 @@ export function set(obj, path, value, onlyPlainObject = false) {
     let current = obj;
     for (let i = 0; i < len - 1; i++) {
         let segment = path[i];
-        let nextSegment = path[i + 1];
-        let isNextNumeric = !isNaN(nextSegment) && isFinite(nextSegment);
+        let nextSegment: number | string = path[i + 1];
+        let isNextNumeric = !isNaN(Number(nextSegment)) && isFinite(Number(nextSegment));
 
         if (!current[segment] || typeof current[segment] !== 'object') {
             current[segment] = (isNextNumeric && !onlyPlainObject) ? [] : {};
@@ -94,7 +147,13 @@ export function set(obj, path, value, onlyPlainObject = false) {
     return obj;
 }
 
-export function get(obj, path) {
+/**
+ * Gets a value from an object using a dot notation path
+ * @param {Record<string, any>} obj - Source object
+ * @param {string} path - Path to get value from (e.g., 'a.b.c')
+ * @returns {any} Value at path or undefined if not found
+ */
+export function get(obj: Record<string, any>, path: string): any {
     const keys = path.split('.');
     let current = obj;
 
@@ -108,15 +167,31 @@ export function get(obj, path) {
     return current;
 }
 
-export function log(text) {
+/**
+ * Logs a message to console
+ * @param {any} text - Message to log
+ */
+export function log(text: any): void {
     console.log(text)
 }
 
-export function error(text) {
+/**
+ * Logs an error message to console
+ * @param {any} text - Error message to log
+ */
+export function error(text: any): void {
     console.error(text)
 }
 
-export function setObservablePoint(observablePoint: ObservablePoint, point: { x: number, y: number } | number | [number, number]): void {
+/**
+ * Sets the position of an ObservablePoint using various input formats
+ * @param {ObservablePoint} observablePoint - The point to modify
+ * @param {Object | number | [number, number]} point - New position value
+ */
+export function setObservablePoint(
+    observablePoint: ObservablePoint, 
+    point: { x: number, y: number } | number | [number, number]
+): void {
     if (typeof point === 'number') {
         observablePoint.set(point);
     }
@@ -128,7 +203,20 @@ export function setObservablePoint(observablePoint: ObservablePoint, point: { x:
     }
 }
 
-export function calculateDistance(x1, y1, x2, y2) {
+/**
+ * Calculates the Euclidean distance between two points
+ * @param {number} x1 - X coordinate of first point
+ * @param {number} y1 - Y coordinate of first point
+ * @param {number} x2 - X coordinate of second point
+ * @param {number} y2 - Y coordinate of second point
+ * @returns {number} Distance between the points
+ */
+export function calculateDistance(
+    x1: number, 
+    y1: number, 
+    x2: number, 
+    y2: number
+): number {
     const dx = x1 - x2;
     const dy = y1 - y2;
     return Math.sqrt(dx * dx + dy * dy);

package/src/hooks/useProps.ts

@@ -25,7 +25,7 @@ export const useProps = (props, defaults = {}): any => {
     }
     for (let key in defaults) {
         if (!(key in obj)) {
-            obj[key] = signal(defaults[key])
+            obj[key] = isPrimitive(defaults[key]) ? signal(defaults[key]) : defaults[key]
         }
     }
     return obj

package/src/index.ts

@@ -1,3 +1,4 @@
+
 import './directives'
 export * from '@signe/reactive'
 export { Howler } from 'howler'
@@ -11,4 +12,6 @@ export { useProps, useDefineProps } from './hooks/useProps'
 export * from './utils/Ease'
 export * from './utils/RadialGradient'
 export * from './components/DisplayObject'
-export { isObservable } from 'rxjs'
+export { isObservable } from 'rxjs'
+export * as Utils from './engine/utils'
+export * as Howl from 'howler'

package/src/utils/RadialGradient.ts

@@ -1,5 +1,13 @@
 import { Texture, ImageSource, DOMAdapter, Matrix } from "pixi.js";
 
+/**
+ * Creates a radial gradient texture that can be used in PixiJS.
+ * @example
+ * const gradient = new RadialGradient(size, size, 0, size, size, 0);
+ * gradient.addColorStop(0, "rgba(255, 255, 0, 1)");
+ * gradient.addColorStop(0.5, "rgba(255, 255, 0, 0.3)");
+ * gradient.addColorStop(0.8, "rgba(255, 255, 0, 0)");
+ */
 export class RadialGradient {
   private canvas: HTMLCanvasElement;
   private ctx: CanvasRenderingContext2D | null;
@@ -9,6 +17,16 @@ export class RadialGradient {
 
   public size = 600;
 
+  /**
+   * Creates a new RadialGradient instance
+   * @param x0 - The x-coordinate of the starting circle
+   * @param y0 - The y-coordinate of the starting circle
+   * @param x1 - The x-coordinate of the ending circle
+   * @param y1 - The y-coordinate of the ending circle
+   * @param x2 - The x-coordinate for gradient transformation
+   * @param y2 - The y-coordinate for gradient transformation
+   * @param focalPoint - The focal point of the gradient (0-1), defaults to 0
+   */
   constructor(
     private x0: number,
     private y0: number,
@@ -38,12 +56,23 @@ export class RadialGradient {
     }
   }
 
+  /**
+   * Adds a color stop to the gradient
+   * @param offset - The position of the color stop (0-1)
+   * @param color - The color value (any valid CSS color string)
+   */
   addColorStop(offset: number, color: string) {
     if (this.gradient) {
       this.gradient.addColorStop(offset, color);
     }
   }
 
+  /**
+   * Renders the gradient and returns the texture with its transformation matrix
+   * @param options - Render options
+   * @param options.translate - Optional translation coordinates
+   * @returns Object containing the texture and transformation matrix
+   */
   render({ translate }: { translate?: { x: number; y: number } } = {}) {
     const { x0, y0, x1, y1, x2, y2, focalPoint } = this;
     const defaultSize = this.size;

package/src/utils/functions.ts

@@ -0,0 +1,7 @@
+export function isPercent(value?: string | number) {
+    if (!value) return false
+    if (typeof value === "string") {
+        return value.endsWith("%")
+    }
+    return false
+}

package/testing/index.ts

@@ -0,0 +1,12 @@
+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 { canvasElement, app } = await bootstrapCanvas(document.getElementById('root'), comp)
+        app.render()
+        return canvasElement.props.children?.[0]
+    }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "declarationMap": true,
+    "rootDir": "src"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "dist",
+    "node_modules"
+  ]
+} 

package/vite.config.ts

@@ -0,0 +1,39 @@
+import { defineConfig } from 'vite'
+import { resolve } from 'path'
+import dts from 'vite-plugin-dts'
+
+export default defineConfig({
+  plugins: [dts()],
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'src/index.ts'),
+      name: 'CanvasEngine'
+    },
+    rollupOptions: {
+      external: ['pixi.js'],
+      output: [
+        // ESM build
+        {
+          format: 'es',
+          dir: 'dist',
+          entryFileNames: 'index.js'
+        },
+        // IIFE build for global usage
+        {
+          format: 'iife',
+          dir: 'dist',
+          entryFileNames: 'index.global.js',
+          name: 'CanvasEngine',
+          globals: {
+            'pixi.js': 'PIXI'
+          },
+        }
+      ]
+    },
+    minify: true,
+    sourcemap: true
+  },
+  define: {
+    'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || 'production')
+  }
+})