@zcomponent/core 1.29.0 → 2.0.0-alpha.2

package/lib/animation/clips/clip.js

@@ -14,6 +14,34 @@ import { StreamTrack } from '../tracks/streamtrack';
  * @param id Optional unique identifier for the clip.
  */
 export class Clip {
+    animation;
+    length;
+    scriptName;
+    id;
+    /** @internal */
+    influencedPathsDirty = new Observable(false);
+    /**
+     *  Optional default parameters for fading animation properties.
+     */
+    defaultFadeParameters;
+    /**
+     * @internal
+     * @default []
+     */
+    _streamTracks = [];
+    /**
+     * @default []
+     */
+    _influencedPaths = [];
+    _tracksByPath = new Map();
+    /**
+     * @default false
+     */
+    _tracksByPathDirty = false;
+    /**
+     * @default []
+     */
+    _tracks = [];
     /**
      * Creates an instance of Clip.
      * @param animation - The associated Animation instance.
@@ -26,20 +54,6 @@ export class Clip {
         this.length = length;
         this.scriptName = scriptName;
         this.id = id;
-        /** @internal */
-        this.influencedPathsDirty = new Observable(false);
-        /** @internal */
-        this._streamTracks = [];
-        this._influencedPaths = [];
-        this._tracksByPath = new Map();
-        this._tracksByPathDirty = false;
-        this._tracks = [];
-        this._dirty = (v) => {
-            if (v) {
-                this.influencedPathsDirty.value = true;
-                this._tracksByPathDirty = true;
-            }
-        };
         if (scriptName)
             this.animation.clips[scriptName] = this;
     }
@@ -88,6 +102,12 @@ export class Clip {
         this._streamTracks = [];
         this.animation.evaluateTouchedPaths(existingPaths);
     }
+    _dirty = (v) => {
+        if (v) {
+            this.influencedPathsDirty.value = true;
+            this._tracksByPathDirty = true;
+        }
+    };
     /**
      * Getter for the mapping of tracks by path.
      *

package/lib/animation/index.d.ts

@@ -1,8 +1,8 @@
 export * from './animation';
-export * from './layerclip';
+export * from './clips/clip';
 export * from './layer';
-export * from './tracks/track';
+export * from './layerclip';
+export * from './stream';
 export * from './tracks/cliptrack';
 export * from './tracks/propertytrack';
-export * from './clips/clip';
-export * from './stream';
+export * from './tracks/track';

package/lib/animation/index.js

@@ -1,8 +1,8 @@
 export * from './animation';
-export * from './layerclip';
+export * from './clips/clip';
 export * from './layer';
-export * from './tracks/track';
+export * from './layerclip';
+export * from './stream';
 export * from './tracks/cliptrack';
 export * from './tracks/propertytrack';
-export * from './clips/clip';
-export * from './stream';
+export * from './tracks/track';

package/lib/animation/layer.d.ts

@@ -41,8 +41,17 @@ export declare class Layer {
      */
     influencedPathsDirty: Observable<boolean, never>;
     private _influencedPaths;
+    /**
+     * @default null
+     */
     private _active;
+    /**
+     * @default []
+     */
     private _queue;
+    /**
+     * @default []
+     */
     private _layerClips;
     /**
      * Creates an instance of Layer.

package/lib/animation/layer.js

@@ -8,6 +8,34 @@ import { StreamState } from './stream';
  * Supports queuing of clips, computation of path properties, and handling fade parameters.
  */
 export class Layer {
+    animation;
+    scriptName;
+    id;
+    /**
+     * Collection of LayerClips indexed by ID.
+     */
+    clips = Object.create(null);
+    /**
+     *  Optional default fade parameters for the layer.
+     */
+    defaultFadeParameters;
+    /**
+     * Observable indicating if the influenced paths are dirty.
+     */
+    influencedPathsDirty = new Observable(false);
+    _influencedPaths = new Set();
+    /**
+     * @default null
+     */
+    _active = null;
+    /**
+     * @default []
+     */
+    _queue = [];
+    /**
+     * @default []
+     */
+    _layerClips = [];
     /**
      * Creates an instance of Layer.
      * @param animation - The animation that the layer belongs to.
@@ -18,18 +46,6 @@ export class Layer {
         this.animation = animation;
         this.scriptName = scriptName;
         this.id = id;
-        /**
-         * Collection of LayerClips indexed by ID.
-         */
-        this.clips = Object.create(null);
-        /**
-         * Observable indicating if the influenced paths are dirty.
-         */
-        this.influencedPathsDirty = new Observable(false);
-        this._influencedPaths = new Set();
-        this._active = null;
-        this._queue = [];
-        this._layerClips = [];
     }
     /**
      * Computes the property value for a given path at a specified time.

package/lib/animation/layerclip.d.ts

@@ -18,14 +18,17 @@ export declare class LayerClip implements Stream {
     readonly id?: string | undefined;
     /**
      * Default behavior for whether the clip loops when it reaches the end.
+     * @default false
      */
     defaultLoop: boolean;
     /**
      * Default speed at which the clip plays.
+     * @default 1
      */
     defaultPlaySpeed: number;
     /**
      * Indicates if the clip should automatically start playing at the beginning of the animation.
+     * @default false
      */
     playAtStart: boolean;
     /**
@@ -36,16 +39,34 @@ export declare class LayerClip implements Stream {
      * Reference to the animation that this layer clip is a part of.
      */
     readonly animation: Animation;
+    /**
+     * @default 0
+     */
     private _t0;
+    /**
+     * @default 0
+     */
     private _pauseTime;
     private _stallStartTime;
     private _t1;
+    /**
+     * @default 1
+     */
     private _rate;
+    /**
+     * @default false
+     */
     private _loop;
     private _lastTickTime;
     private _lastClipTime;
     private _lastLoop;
+    /**
+     * @default false
+     */
     private _stopped;
+    /**
+     * @default "Paused"
+     */
     private _state;
     state: Observable<StreamState, never>;
     playing: Observable<boolean, never>;

package/lib/animation/layerclip.js

@@ -9,6 +9,70 @@ import { resolveClipTimeLoops } from './tracks/track';
  *
  */
 export class LayerClip {
+    layer;
+    clip;
+    scriptName;
+    id;
+    /**
+     * Default behavior for whether the clip loops when it reaches the end.
+     * @default false
+     */
+    defaultLoop = false;
+    /**
+     * Default speed at which the clip plays.
+     * @default 1
+     */
+    defaultPlaySpeed = 1;
+    /**
+     * Indicates if the clip should automatically start playing at the beginning of the animation.
+     * @default false
+     */
+    playAtStart = false;
+    /**
+     * Function providing the current time, used for synchronizing the clip's playback.
+     */
+    timeSource;
+    /**
+     * Reference to the animation that this layer clip is a part of.
+     */
+    animation;
+    /**
+     * @default 0
+     */
+    _t0 = 0;
+    /**
+     * @default 0
+     */
+    _pauseTime = 0;
+    _stallStartTime;
+    _t1;
+    /**
+     * @default 1
+     */
+    _rate = 1;
+    /**
+     * @default false
+     */
+    _loop = false;
+    _lastTickTime;
+    _lastClipTime;
+    _lastLoop;
+    /**
+     * @default false
+     */
+    _stopped = false;
+    /**
+     * @default "Paused"
+     */
+    _state = StreamState.Paused;
+    state = new Observable(this._state);
+    playing = new Observable(false);
+    stalled = new Observable(false);
+    active = new Observable(false);
+    onPlaying = new Event();
+    onPaused = new Event();
+    onEnded = new Event();
+    onLoop = new Event();
     /**
      * Creates an instance of LayerClip.
      * @param layer - The layer that this clip belongs to.
@@ -21,51 +85,6 @@ export class LayerClip {
         this.clip = clip;
         this.scriptName = scriptName;
         this.id = id;
-        /**
-         * Default behavior for whether the clip loops when it reaches the end.
-         */
-        this.defaultLoop = false;
-        /**
-         * Default speed at which the clip plays.
-         */
-        this.defaultPlaySpeed = 1;
-        /**
-         * Indicates if the clip should automatically start playing at the beginning of the animation.
-         */
-        this.playAtStart = false;
-        this._t0 = 0;
-        this._pauseTime = 0;
-        // private _s0: number = 0;
-        this._rate = 1;
-        this._loop = false;
-        this._stopped = false;
-        this._state = StreamState.Paused;
-        this.state = new Observable(this._state);
-        this.playing = new Observable(false);
-        this.stalled = new Observable(false);
-        this.active = new Observable(false);
-        this.onPlaying = new Event();
-        this.onPaused = new Event();
-        this.onEnded = new Event();
-        this.onLoop = new Event();
-        this._clipDirty = (v) => {
-            if (v)
-                this._lastClipTime = undefined;
-        };
-        this._stateUpdate = (s) => {
-            this.playing.value = s === StreamState.Playing;
-            switch (s) {
-                case StreamState.Ended:
-                    this.onEnded.emit(this);
-                    break;
-                case StreamState.Playing:
-                    this.onPlaying.emit(this);
-                    break;
-                case StreamState.Paused:
-                    this.onPaused.emit(this);
-                    break;
-            }
-        };
         this.animation = layer.animation;
         this._t1 = clip.length;
         layer._registerLayerClip(this);
@@ -74,6 +93,10 @@ export class LayerClip {
             layer.animation.layerClipByID.set(id, this);
         this.state.addListener(this._stateUpdate);
     }
+    _clipDirty = (v) => {
+        if (v)
+            this._lastClipTime = undefined;
+    };
     /** @internal */
     tick(touchedPaths, force) {
         const t = this._getTime();
@@ -136,6 +159,20 @@ export class LayerClip {
     _getTime() {
         return Math.floor(this.timeSource?.() ?? this.animation.timeSource?.() ?? performance.now());
     }
+    _stateUpdate = (s) => {
+        this.playing.value = s === StreamState.Playing;
+        switch (s) {
+            case StreamState.Ended:
+                this.onEnded.emit(this);
+                break;
+            case StreamState.Playing:
+                this.onPlaying.emit(this);
+                break;
+            case StreamState.Paused:
+                this.onPaused.emit(this);
+                break;
+        }
+    };
     /**
      * Queues the LayerClip for playback with optional play options.
      *

package/lib/animation/tracks/cliptrack.d.ts

@@ -12,11 +12,29 @@ import { Track } from './track';
  */
 export declare class ClipTrack extends Track {
     readonly clip: Clip;
+    /**
+     * @default []
+     */
     private _weights;
+    /**
+     * @default {}
+     */
     private _weightsById;
+    /**
+     * @default false
+     */
     private _weightsDirty;
+    /**
+     * @default []
+     */
     private _entities;
+    /**
+     * @default {}
+     */
     private _entitiesById;
+    /**
+     * @default false
+     */
     private _entitiesDirty;
     private _lastTick?;
     private _lastLoopNumber?;

package/lib/animation/tracks/cliptrack.js

@@ -6,6 +6,33 @@ import { resolveClipTimeLoops, resolveKeyframes, resolveKeyframeValue, Track } f
  * @param id Optional unique identifier for the ClipTrack.
  */
 export class ClipTrack extends Track {
+    clip;
+    /**
+     * @default []
+     */
+    _weights = [];
+    /**
+     * @default {}
+     */
+    _weightsById = {};
+    /**
+     * @default false
+     */
+    _weightsDirty = false;
+    /**
+     * @default []
+     */
+    _entities = [];
+    /**
+     * @default {}
+     */
+    _entitiesById = {};
+    /**
+     * @default false
+     */
+    _entitiesDirty = false;
+    _lastTick;
+    _lastLoopNumber;
     /**
      * Creates an instance of ClipTrack.
      * @param clip - The associated Clip to embed.
@@ -14,12 +41,6 @@ export class ClipTrack extends Track {
     constructor(clip, id) {
         super(clip.animation, id);
         this.clip = clip;
-        this._weights = [];
-        this._weightsById = {};
-        this._weightsDirty = false;
-        this._entities = [];
-        this._entitiesById = {};
-        this._entitiesDirty = false;
         this.clip.influencedPathsDirty.addListener(v => {
             if (v)
                 this.influencedPathsDirty.value = true;

package/lib/animation/tracks/functiontrack.d.ts

@@ -19,8 +19,17 @@ export interface ResolvedFunctionTrackEntity {
  */
 export declare class FunctionTrack extends Track {
     readonly animation: Animation;
+    /**
+     * @default []
+     */
     private _entities;
+    /**
+     * @default {}
+     */
     private _entitiesById;
+    /**
+     * @default false
+     */
     private _entitiesDirty;
     private _lastTick?;
     /**

package/lib/animation/tracks/functiontrack.js

@@ -7,6 +7,21 @@ import { Track } from './track';
  * @param animation The associated Animation instance.
  */
 export class FunctionTrack extends Track {
+    animation;
+    /**
+     * @default []
+     */
+    _entities = [];
+    /**
+     * @default {}
+     */
+    _entitiesById = {};
+    /**
+     * @default false
+     */
+    _entitiesDirty = false;
+    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: ignore for now
+    _lastTick;
     /**
      *  Creates an instance of FunctionTrack.
      * @param animation The associated Animation instance.
@@ -14,9 +29,6 @@ export class FunctionTrack extends Track {
     constructor(animation) {
         super(animation);
         this.animation = animation;
-        this._entities = [];
-        this._entitiesById = {};
-        this._entitiesDirty = false;
     }
     /**
      * Getter for the list of paths influenced by the track.
@@ -111,6 +123,7 @@ export class FunctionTrack extends Track {
      * @param active The current active LayerClip, null, or undefined.
      */
     streamPause(isActive, active) { }
+    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: ignore for now
     _resolveBlocksBetween(tstart, tend, rate, clipLength) {
         const blocks = this.sortedBlocks;
         if (rate < 0) {

package/lib/animation/tracks/propertytrack.d.ts

@@ -1,4 +1,4 @@
-import { FadeParameters, BlendType } from '../../data';
+import { BlendType, FadeParameters } from '../../data';
 import { Animation } from '../animation';
 import { Keyframe } from '../keyframe';
 import { Track } from './track';
@@ -23,11 +23,29 @@ export declare class PropertyTrack extends Track {
     path: string;
     private _property;
     private _path;
+    /**
+     * @default []
+     */
     private _keyframes;
+    /**
+     * @default {}
+     */
     private _keyframesById;
+    /**
+     * @default false
+     */
     private _keyframesDirty;
+    /**
+     * @default []
+     */
     private _weights;
+    /**
+     * @default {}
+     */
     private _weightsById;
+    /**
+     * @default false
+     */
     private _weightsDirty;
     /**
      * Optional parameters for fading animation properties.
@@ -35,6 +53,7 @@ export declare class PropertyTrack extends Track {
     fadeParameters?: Partial<FadeParameters>;
     /**
      * Blend type for interpolating values.
+     * @default "overlay"
      */
     blend: BlendType;
     /**

package/lib/animation/tracks/propertytrack.js

@@ -15,6 +15,51 @@ const _scratch = new Observable(undefined);
  * @param id Optional unique identifier for the PropertyTrack.
  */
 export class PropertyTrack extends Track {
+    _entityID;
+    _entity;
+    /**
+     *  Path representing the property being animated.
+     */
+    path;
+    _property;
+    _path;
+    /**
+     * @default []
+     */
+    _keyframes = [];
+    /**
+     * @default {}
+     */
+    _keyframesById = {};
+    /**
+     * @default false
+     */
+    _keyframesDirty = false;
+    /**
+     * @default []
+     */
+    _weights = [];
+    /**
+     * @default {}
+     */
+    _weightsById = {};
+    /**
+     * @default false
+     */
+    _weightsDirty = false;
+    /**
+     * Optional parameters for fading animation properties.
+     */
+    fadeParameters;
+    /**
+     * Blend type for interpolating values.
+     * @default "overlay"
+     */
+    blend = 'overlay';
+    /**
+     * Paths influenced by this track.
+     */
+    influencedPaths;
     /**
      * Creates an instance of PropertyTrack.
      * @param anim - The associated Animation instance.
@@ -23,20 +68,12 @@ export class PropertyTrack extends Track {
      * @param property - The property or array of properties to be animated.
      * @param id - Optional unique identifier for the PropertyTrack.
      */
-    constructor(anim, _entityID, _entity, property, id) {
+    constructor(anim, _entityID, 
+    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: avoiding changing constructor signature
+    _entity, property, id) {
         super(anim, id);
         this._entityID = _entityID;
         this._entity = _entity;
-        this._keyframes = [];
-        this._keyframesById = {};
-        this._keyframesDirty = false;
-        this._weights = [];
-        this._weightsById = {};
-        this._weightsDirty = false;
-        /**
-         * Blend type for interpolating values.
-         */
-        this.blend = 'overlay';
         if (Array.isArray(property)) {
             this._property = property[0];
             this._path = property.slice(1);

package/lib/animation/tracks/streamtrack.d.ts

@@ -16,11 +16,29 @@ export declare class StreamTrack extends Track {
     private _entity;
     private _property;
     private _stream;
+    /**
+     * @default []
+     */
     private _entities;
+    /**
+     * @default {}
+     */
     private _entitiesById;
+    /**
+     * @default false
+     */
     private _entitiesDirty;
+    /**
+     * @default []
+     */
     private _weights;
+    /**
+     * @default {}
+     */
     private _weightsById;
+    /**
+     * @default false
+     */
     private _weightsDirty;
     private _lastTick?;
     private _lastLoopNumber?;