modern-canvas 0.14.5 → 0.14.7

package/dist/scene/2d/Camera2D.d.ts

@@ -1,12 +1,12 @@
-import type { InputEvent, InputEventKey, Vector2Data, WheelInputEvent } from '../../core';
+import type { InputEvent, InputEventKey, Vector2Like, WheelInputEvent } from '../../core';
 import type { Node, SceneTree } from '../main';
 import type { Node2DEvents, Node2DProperties } from './Node2D';
 import { Transform2D, Vector2 } from '../../core';
 import { Node2D } from './Node2D';
 export interface Camera2DProperties extends Node2DProperties {
-    zoom?: Vector2Data;
-    minZoom?: Vector2Data;
-    maxZoom?: Vector2Data;
+    zoom?: Vector2Like;
+    minZoom?: Vector2Like;
+    maxZoom?: Vector2Like;
 }
 export interface Camera2DEvents extends Node2DEvents {
     updateCanvasTransform: [];
@@ -27,13 +27,13 @@ export declare class Camera2D extends Node2D {
     };
     protected _zoom: Vector2;
     get zoom(): Vector2;
-    set zoom(val: Vector2Data);
+    set zoom(val: Vector2Like);
     protected _minZoom: Vector2;
     get minZoom(): Vector2;
-    set minZoom(val: Vector2Data);
+    set minZoom(val: Vector2Like);
     protected _maxZoom: Vector2;
     get maxZoom(): Vector2;
-    set maxZoom(val: Vector2Data);
+    set maxZoom(val: Vector2Like);
     constructor(properties?: Partial<Camera2DProperties>, nodes?: Node[]);
     setProperties(properties?: Record<string, any>): this;
     addZoom(x: number, y?: number): this;
@@ -45,7 +45,7 @@ export declare class Camera2D extends Node2D {
     updateCanvasTransform(): void;
     syncCanvasTransform(): void;
     protected _treeEnter(tree: SceneTree): void;
-    toGlobal<P extends Vector2Data = Vector2>(screenPos: Vector2Data, newPos?: P): P;
-    toScreen<P extends Vector2Data = Vector2>(globalPos: Vector2Data, newPos?: P): P;
+    toGlobal<P extends Vector2Like = Vector2>(screenPos: Vector2Like, newPos?: P): P;
+    toScreen<P extends Vector2Like = Vector2>(globalPos: Vector2Like, newPos?: P): P;
     toJSON(): Record<string, any>;
 }

package/dist/scene/2d/FlexLayout.d.ts

@@ -1,6 +1,5 @@
 import type { Node as YogaNode } from 'yoga-layout/load';
-import type { Element2DStyle } from './element';
-import type { Element2D } from './Element2D';
+import type { Element2D, Element2DStyle } from './element';
 export declare const edgeMap: {
     left: number;
     top: number;

package/dist/scene/2d/Node2D.d.ts

@@ -1,4 +1,4 @@
-import type { Vector2Data } from '../../core';
+import type { Vector2Like } from '../../core';
 import type { CanvasBatchable, CanvasItemEvents, CanvasItemProperties, Node } from '../main';
 import { Transform2D, Vector2 } from '../../core';
 import { CanvasItem } from '../main';
@@ -33,6 +33,6 @@ export declare class Node2D extends CanvasItem {
     protected _transformVertices(batchable: CanvasBatchable): Float32Array;
     protected _relayout(batchables: CanvasBatchable[]): CanvasBatchable[];
     protected _process(delta: number): void;
-    toLocal<P extends Vector2Data = Vector2>(globalPos: Vector2Data, newPos?: P): P;
-    toGlobal<P extends Vector2Data = Vector2>(localPos: Vector2Data, newPos?: P): P;
+    toLocal<P extends Vector2Like = Vector2>(globalPos: Vector2Like, newPos?: P): P;
+    toGlobal<P extends Vector2Like = Vector2>(localPos: Vector2Like, newPos?: P): P;
 }

package/dist/scene/2d/TextureRect2D.d.ts

@@ -1,7 +1,7 @@
 import type { Node } from '../main';
 import type { Texture2D } from '../resources';
-import type { Element2DProperties } from './Element2D';
-import { Element2D } from './Element2D';
+import type { Element2DProperties } from './element';
+import { Element2D } from './element';
 export interface TextureRect2DProperties extends Element2DProperties {
 }
 export declare class TextureRect2D<T extends Texture2D = Texture2D> extends Element2D {

package/dist/scene/2d/TransformRect2D.d.ts

@@ -1,7 +1,7 @@
 import type { Node } from '../main';
-import type { BaseElement2DProperties } from './element';
-import { Element2D } from './Element2D';
-export interface TransformRect2DProperties extends BaseElement2DProperties {
+import type { Element2DProperties } from './element';
+import { Element2D } from './element';
+export interface TransformRect2DProperties extends Element2DProperties {
 }
 export declare class TransformRect2D extends Element2D {
     handleSize: number;

package/dist/scene/2d/element/{BaseElement2D.d.ts → Element2D.d.ts}

@@ -1,9 +1,11 @@
-import type { Background, Fill, Foreground, Outline, Shadow, Shape, Style, Text } from 'modern-idoc';
-import type { InputEvent, InputEventKey, Vector2Data } from '../../../core';
+import type { Background, Fill, Foreground, Outline, Shadow, Shape, Text } from 'modern-idoc';
+import type { InputEvent, InputEventKey, Vector2Like } from '../../../core';
 import type { Node, Rectangulable, RectangulableEvents, SceneTree } from '../../main';
 import type { Node2DEvents, Node2DProperties } from '../Node2D';
-import { Rectangle, Vector2 } from '../../../core';
+import type { Element2DStyleProperties } from './Element2DStyle';
+import { Aabb2D, Obb2D, Vector2 } from '../../../core';
 import { ColorFilterEffect } from '../../effects';
+import { directionMap, FlexLayout } from '../FlexLayout';
 import { Node2D } from '../Node2D';
 import { Element2DBackground } from './Element2DBackground';
 import { Element2DFill } from './Element2DFill';
@@ -16,14 +18,14 @@ import { Element2DText } from './Element2DText';
 export interface BaseElement2DEvents extends Node2DEvents, RectangulableEvents {
     updateStyleProperty: [key: string, value: any, oldValue: any];
 }
-export interface BaseElement2D {
+export interface Element2D {
     on: <K extends keyof BaseElement2DEvents & string>(event: K, listener: (...args: BaseElement2DEvents[K]) => void) => this;
     once: <K extends keyof BaseElement2DEvents & string>(event: K, listener: (...args: BaseElement2DEvents[K]) => void) => this;
     off: <K extends keyof BaseElement2DEvents & string>(event: K, listener: (...args: BaseElement2DEvents[K]) => void) => this;
     emit: <K extends keyof BaseElement2DEvents & string>(event: K, ...args: BaseElement2DEvents[K]) => this;
 }
-export interface BaseElement2DProperties extends Node2DProperties {
-    style: Style;
+export interface Element2DProperties extends Node2DProperties {
+    style: Partial<Element2DStyleProperties>;
     background: Background;
     shape: Shape;
     fill: Fill;
@@ -31,62 +33,65 @@ export interface BaseElement2DProperties extends Node2DProperties {
     foreground: Foreground;
     text: Text;
     shadow: Shadow;
+    layoutMode: LayoutMode;
 }
-export declare class BaseElement2D extends Node2D implements Rectangulable {
+export type LayoutMode = 'inherit' | 'absolute' | 'flex';
+export declare class Element2D extends Node2D implements Rectangulable {
+    layoutMode: LayoutMode;
+    _flex: FlexLayout;
     readonly size: Vector2;
     protected _allowPointerEvents: boolean;
     protected _overflowHidden: boolean;
     protected _style: Element2DStyle;
     get style(): Element2DStyle;
-    set style(value: BaseElement2DProperties['style']);
+    set style(value: Element2DProperties['style']);
     protected _background: Element2DBackground;
     get background(): Element2DBackground;
-    set background(value: BaseElement2DProperties['background']);
+    set background(value: Element2DProperties['background']);
     protected _shape: Element2DShape;
     get shape(): Element2DShape;
-    set shape(value: BaseElement2DProperties['shape']);
+    set shape(value: Element2DProperties['shape']);
     protected _fill: Element2DFill;
     get fill(): Element2DFill;
-    set fill(value: BaseElement2DProperties['fill']);
+    set fill(value: Element2DProperties['fill']);
     protected _outline: Element2DOutline;
     get outline(): Element2DOutline;
-    set outline(value: BaseElement2DProperties['outline']);
+    set outline(value: Element2DProperties['outline']);
     protected _foreground: Element2DForeground;
     get foreground(): Element2DForeground;
-    set foreground(value: BaseElement2DProperties['foreground']);
+    set foreground(value: Element2DProperties['foreground']);
     protected _text: Element2DText;
     get text(): Element2DText;
-    set text(value: BaseElement2DProperties['text']);
+    set text(value: Element2DProperties['text']);
     protected _shadow: Element2DShadow;
     get shadow(): Element2DShadow;
-    set shadow(value: BaseElement2DProperties['shadow']);
+    set shadow(value: Element2DProperties['shadow']);
     protected _styleFilter?: ColorFilterEffect;
-    constructor(properties?: Partial<BaseElement2DProperties>, nodes?: Node[]);
+    constructor(properties?: Partial<Element2DProperties>, nodes?: Node[]);
     protected _treeEnter(tree: SceneTree): void;
+    protected _parented(parent: Node): void;
+    protected _unparented(oldParent: Node): void;
     setProperties(properties?: Record<string, any>): this;
     onUpdateStyleProperty(key: string, value: any, oldValue: any): void;
     protected _updateStyleProperty(key: string, value: any, oldValue: any): void;
     protected _process(delta: number): void;
+    getGlobalLayoutMode(): Omit<LayoutMode, 'inherit'>;
+    updateLayout(): void;
+    calculateLayout(width?: number | 'auto', height?: number | 'auto', direction?: typeof directionMap[keyof typeof directionMap]): void;
     protected _getStyleFilter(): ColorFilterEffect;
     protected _updateMaskImage(maskImage?: string): void;
     updateGlobalTransform(): void;
-    getRect(): Rectangle;
-    protected _getPointArray(): Vector2Data[];
-    getAabb(): Rectangle;
-    getGlobalAabb(): Rectangle;
-    getObb(): {
-        rect: Rectangle;
-        rotation: number;
-    };
-    getGlobalObb(): {
-        rect: Rectangle;
-        rotation: number;
-    };
+    getRect(): Aabb2D;
+    protected _getPointArray(): Vector2Like[];
+    getAabb(): Aabb2D;
+    getGlobalAabb(): Aabb2D;
+    getObb(): Obb2D;
+    getGlobalObb(): Obb2D;
     protected _updateMask(): void;
     protected _draw(): void;
     protected _drawContent(): void;
     input(event: InputEvent, key: InputEventKey): void;
-    protected _positionInput(localPos: Vector2Data, key: InputEventKey): boolean;
+    protected _positionInput(localPos: Vector2Like, key: InputEventKey): boolean;
     protected _input(event: InputEvent, key: InputEventKey): void;
     toJSON(): Record<string, any>;
 }

package/dist/scene/2d/element/Element2DFill.d.ts

@@ -1,11 +1,11 @@
 import type { Fill, NormalizedFill } from 'modern-idoc';
 import type { AnimatedTexture, Texture2D } from '../../resources';
-import type { BaseElement2D } from './BaseElement2D';
+import type { Element2D } from './Element2D';
 import { CoreObject } from '../../../core';
 export interface Element2DFill extends NormalizedFill {
 }
 export declare class Element2DFill extends CoreObject {
-    parent: BaseElement2D;
+    parent: Element2D;
     enabled: boolean;
     color?: NormalizedFill['color'];
     image?: NormalizedFill['image'];
@@ -19,7 +19,7 @@ export declare class Element2DFill extends CoreObject {
     opacity?: NormalizedFill['opacity'];
     texture?: Texture2D;
     animatedTexture?: AnimatedTexture;
-    constructor(parent: BaseElement2D);
+    constructor(parent: Element2D);
     protected _setProperties(properties?: NormalizedFill): this;
     setProperties(properties?: Fill): this;
     protected _updateProperty(key: string, value: any, oldValue: any): void;

package/dist/scene/2d/element/Element2DShadow.d.ts

@@ -1,14 +1,14 @@
 import type { NormalizedShadow, Shadow } from 'modern-idoc';
-import type { BaseElement2D } from './BaseElement2D';
+import type { Element2D } from './Element2D';
 import { CoreObject } from '../../../core';
 export declare class Element2DShadow extends CoreObject {
-    parent: BaseElement2D;
+    parent: Element2D;
     enabled: boolean;
     color: NormalizedShadow['color'];
     blur: NormalizedShadow['blur'];
     offsetY: NormalizedShadow['offsetX'];
     offsetX: NormalizedShadow['offsetY'];
-    constructor(parent: BaseElement2D);
+    constructor(parent: Element2D);
     setProperties(properties?: Shadow): this;
     protected _updateProperty(key: string, value: any, oldValue: any): void;
     updateEffect(): void;

package/dist/scene/2d/element/Element2DShape.d.ts

@@ -1,16 +1,16 @@
 import type { NormalizedShape, Shape } from 'modern-idoc';
-import type { BaseElement2D } from './BaseElement2D';
+import type { Element2D } from './Element2D';
 import { Path2DSet } from 'modern-path2d';
 import { CoreObject } from '../../../core';
 export declare class Element2DShape extends CoreObject {
-    parent: BaseElement2D;
+    parent: Element2D;
     enabled: boolean;
     preset: NormalizedShape['preset'];
     svg: NormalizedShape['svg'];
     viewBox: NormalizedShape['viewBox'];
     paths: NormalizedShape['paths'];
     protected _path2DSet: Path2DSet;
-    constructor(parent: BaseElement2D);
+    constructor(parent: Element2D);
     setProperties(properties?: Shape): this;
     protected _updateProperty(key: string, value: any, oldValue: any): void;
     protected _updatePath2DSet(): void;

package/dist/scene/2d/element/Element2DText.d.ts

@@ -4,14 +4,14 @@ import type { MeasureResult } from 'modern-text';
 import type { RectangleLike } from '../../../core';
 import type { CanvasContext, TransformVertex } from '../../main';
 import type { Texture2D } from '../../resources';
-import type { BaseElement2D } from './BaseElement2D';
+import type { Element2D } from './Element2D';
 import { BoundingBox } from 'modern-path2d';
 import { Text } from 'modern-text';
 import { CoreObject } from '../../../core';
 import { CanvasTexture } from '../../resources';
 export type TextDrawMode = 'auto' | 'texture' | 'path';
 export declare class Element2DText extends CoreObject {
-    parent: BaseElement2D;
+    parent: Element2D;
     enabled: boolean;
     content: NormalizedText['content'];
     style: NormalizedText['style'];
@@ -29,7 +29,7 @@ export declare class Element2DText extends CoreObject {
         texture: Texture2D | undefined;
         box: RectangleLike;
     }>;
-    constructor(parent: BaseElement2D);
+    constructor(parent: Element2D);
     setProperties(properties?: TextProperties): this;
     protected _updateProperty(key: string, value: any, oldValue: any): void;
     update(): void;

package/dist/scene/2d/element/index.d.ts

@@ -1,4 +1,4 @@
-export * from './BaseElement2D';
+export * from './Element2D';
 export * from './Element2DBackground';
 export * from './Element2DFill';
 export * from './Element2DForeground';

package/dist/scene/2d/index.d.ts

@@ -1,6 +1,5 @@
 export * from './Camera2D';
 export * from './element';
-export * from './Element2D';
 export * from './FlexLayout';
 export * from './Lottie2D';
 export * from './Node2D';

package/dist/scene/effects/MaskEffect.d.ts

@@ -4,12 +4,12 @@ import type { Texture2D } from '../resources';
 import { Effect } from '../main/Effect';
 import { Material } from '../resources';
 export interface MaskEffectProperties extends EffectProperties {
-    src?: string;
+    image?: string;
 }
 export declare class MaskEffect extends Effect {
     static material: Material;
     texture?: Texture2D<ImageBitmap>;
-    src: string;
+    image: string;
     constructor(properties?: Partial<MaskEffectProperties>, children?: Node[]);
     load(): Promise<void>;
     protected _updateProperty(key: string, value: any, oldValue: any): void;

package/dist/scene/main/Effect.d.ts

@@ -1,8 +1,10 @@
 import type { GlRenderer, RectangleLike } from '../../core';
 import type { Material } from '../resources';
+import type { Rectangulable } from './interfaces';
 import type { Node } from './Node';
 import type { SceneTree } from './SceneTree';
-import type { TimelineNodeProperties } from './TimelineNode';
+import type { TimelineNodeEvents, TimelineNodeProperties } from './TimelineNode';
+import { Aabb2D } from '../../core';
 import { TimelineNode } from './TimelineNode';
 import { Viewport } from './Viewport';
 export type EffectMode = 'before' | 'parent' | 'children' | 'transition';
@@ -20,7 +22,16 @@ export interface EffectContext {
     from?: Viewport;
     to?: Viewport;
 }
-export declare class Effect extends TimelineNode {
+export interface EffectEvents extends TimelineNodeEvents {
+    updateRect: [];
+}
+export interface Effect {
+    on: <K extends keyof EffectEvents & string>(event: K, listener: (...args: EffectEvents[K]) => void) => this;
+    once: <K extends keyof EffectEvents & string>(event: K, listener: (...args: EffectEvents[K]) => void) => this;
+    off: <K extends keyof EffectEvents & string>(event: K, listener: (...args: EffectEvents[K]) => void) => this;
+    emit: <K extends keyof EffectEvents & string>(event: K, ...args: EffectEvents[K]) => this;
+}
+export declare class Effect extends TimelineNode implements Rectangulable {
     material?: Material;
     effectMode?: EffectMode;
     glsl?: string;
@@ -36,13 +47,15 @@ export declare class Effect extends TimelineNode {
     /** Temporary nodes for transition */
     protected _previousSibling?: Node;
     protected _nextSibling?: Node;
+    protected _rect: RectangleLike;
     constructor(properties?: Partial<EffectProperties>, children?: Node[]);
+    requestRender(): void;
     protected _updateProperty(key: string, value: any, oldValue: any): void;
     protected _treeEnter(tree: SceneTree): void;
     protected _treeExit(oldTree: SceneTree): void;
     protected _onProcessing(): void;
     protected _onNodeProcessed(node: Node): void;
-    protected _rect: RectangleLike;
+    getRect(): Aabb2D;
     protected _processParent(): void;
     protected _processChildren(): void;
     _onProcess(delta?: number): void;

package/dist/scene/main/Viewport.d.ts

@@ -1,8 +1,8 @@
-import type { GlRenderer, RectangleLike, Vector2, Vector2Data } from '../../core';
+import type { GlRenderer, RectangleLike, Vector2, Vector2Like } from '../../core';
 import type { Texture2D } from '../resources';
 import type { Rectangulable, RectangulableEvents } from './interfaces';
 import type { NodeEvents } from './Node';
-import { Rectangle, Transform2D } from '../../core';
+import { Aabb2D, Transform2D } from '../../core';
 import { RenderTarget } from '../resources';
 import { Node } from './Node';
 export interface ViewportEvents extends NodeEvents, RectangulableEvents {
@@ -37,7 +37,7 @@ export declare class Viewport extends Node implements Rectangulable {
     renderStart(renderer: GlRenderer, frame?: RectangleLike): void;
     renderEnd(renderer: GlRenderer, oldViewport: Viewport | undefined): void;
     render(renderer: GlRenderer, next?: () => void): void;
-    getRect(): Rectangle;
-    toCanvasGlobal<P extends Vector2Data = Vector2>(screenPos: Vector2Data, newPos?: P): P;
-    toCanvasScreen<P extends Vector2Data = Vector2>(globalPos: Vector2Data, newPos?: P): P;
+    getRect(): Aabb2D;
+    toCanvasGlobal<P extends Vector2Like = Vector2>(screenPos: Vector2Like, newPos?: P): P;
+    toCanvasScreen<P extends Vector2Like = Vector2>(globalPos: Vector2Like, newPos?: P): P;
 }

package/dist/scene/main/interfaces/Rectangulable.d.ts

@@ -1,4 +1,4 @@
-import type { Rectangle } from '../../../core';
+import type { Aabb2D } from '../../../core';
 export interface RectangulableEvents {
     updateRect: [];
 }
@@ -9,5 +9,5 @@ export interface Rectangulable {
     emit: <K extends keyof RectangulableEvents & string>(event: K, ...args: RectangulableEvents[K]) => this;
 }
 export interface Rectangulable {
-    getRect: () => Rectangle;
+    getRect: () => Aabb2D;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modern-canvas",
   "type": "module",
-  "version": "0.14.5",
+  "version": "0.14.7",
   "packageManager": "pnpm@10.19.0",
   "description": "A JavaScript WebGL rendering engine. only the ESM.",
   "author": "wxm",
@@ -65,8 +65,8 @@
     "earcut": "^3.0.2",
     "modern-font": "^0.4.4",
     "modern-idoc": "^0.10.6",
-    "modern-path2d": "^1.4.14",
-    "modern-text": "^1.10.4"
+    "modern-path2d": "^1.4.15",
+    "modern-text": "^1.10.5"
   },
   "peerDependencies": {
     "lottie-web": "^5",
@@ -85,9 +85,9 @@
     }
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^6.5.1",
+    "@antfu/eslint-config": "^6.6.1",
     "@types/earcut": "^3.0.0",
-    "@types/node": "^24.10.1",
+    "@types/node": "^24.10.2",
     "bumpp": "^10.3.2",
     "conventional-changelog-cli": "^5.0.0",
     "eslint": "^9.39.1",

package/dist/scene/2d/Element2D.d.ts

@@ -1,28 +0,0 @@
-import type { Node } from '../main';
-import type { BaseElement2DEvents, BaseElement2DProperties, Element2DStyleProperties } from './element';
-import { BaseElement2D } from './element';
-import { directionMap, FlexLayout } from './FlexLayout';
-export type LayoutMode = 'inherit' | 'absolute' | 'flex';
-export interface Element2DEvents extends BaseElement2DEvents {
-}
-export interface Element2D {
-    on: <K extends keyof Element2DEvents & string>(event: K, listener: (...args: Element2DEvents[K]) => void) => this;
-    once: <K extends keyof Element2DEvents & string>(event: K, listener: (...args: Element2DEvents[K]) => void) => this;
-    off: <K extends keyof Element2DEvents & string>(event: K, listener: (...args: Element2DEvents[K]) => void) => this;
-    emit: <K extends keyof Element2DEvents & string>(event: K, ...args: Element2DEvents[K]) => this;
-}
-export interface Element2DProperties extends BaseElement2DProperties {
-    style: Partial<Element2DStyleProperties>;
-    layoutMode: LayoutMode;
-}
-export declare class Element2D extends BaseElement2D {
-    layoutMode: LayoutMode;
-    _flex: FlexLayout;
-    constructor(properties?: Partial<Element2DProperties>, nodes?: Node[]);
-    getGlobalLayoutMode(): Omit<LayoutMode, 'inherit'>;
-    protected _updateStyleProperty(key: string, value: any, oldValue: any): void;
-    protected _parented(parent: Node): void;
-    protected _unparented(oldParent: Node): void;
-    updateLayout(): void;
-    calculateLayout(width?: number | 'auto', height?: number | 'auto', direction?: typeof directionMap[keyof typeof directionMap]): void;
-}