@zcomponent/core 0.0.29 → 0.0.31-beta

package/lib/animation/animation.d.ts

@@ -57,6 +57,7 @@ export declare class Animation {
     private _emitPendingEvents;
     private _resolvePath;
     private _evaluatePath;
+    start(): void;
 }
 export interface EntityPath {
     entity: any;

package/lib/animation/animation.js

@@ -186,4 +186,12 @@ export class Animation {
         }
         resolved[0][resolved[1]] = val;
     }
+    start() {
+        for (const layer of this._layers) {
+            for (const clip of Object.values(layer.clips)) {
+                if (clip.playAtStart)
+                    clip.play();
+            }
+        }
+    }
 }

package/lib/animation/layerclip.d.ts

@@ -11,6 +11,7 @@ export declare class LayerClip implements Stream {
     readonly id?: string | undefined;
     defaultLoop: boolean;
     defaultPlaySpeed: number;
+    playAtStart: boolean;
     timeSource: (() => number) | undefined;
     readonly animation: Animation;
     private _t0;

package/lib/animation/layerclip.js

@@ -8,6 +8,7 @@ export class LayerClip {
         this.id = id;
         this.defaultLoop = false;
         this.defaultPlaySpeed = 1;
+        this.playAtStart = false;
         this._t0 = 0;
         this._pauseTime = 0;
         // private _s0: number = 0;

package/lib/data/animation.d.ts

@@ -36,6 +36,7 @@ export interface LayerClip {
     reverse?: boolean;
     playbackSpeed?: number;
     scriptName?: string;
+    playAtStart?: boolean;
 }
 export type ActiveLayerClips = ByID<string | undefined>;
 export declare enum ClipType {
@@ -90,6 +91,10 @@ export interface BaseTrack {
     id: string;
     type: TrackType;
     entityID: string;
+    lock?: {
+        track?: boolean;
+        weight?: boolean;
+    };
 }
 export interface PropertyTrack extends BaseTrack {
     type: TrackType.Property;

package/lib/data/animation.js

@@ -6,15 +6,72 @@ export var ClipType;
 })(ClipType || (ClipType = {}));
 // TODO: it's a temporary placement for this object
 export const predefinedCurve = {
-    linear: [[[0, 0], [0.5, 0.5], [0.5, 0.5], [1, 1]]],
-    ease: [[[0, 0], [0.25, 0.1], [0.25, 1], [1, 1]]],
-    easeIn: [[[0, 0], [0.42, 0], [1, 1], [1, 1]]],
-    easeOut: [[[0, 0], [0, 0], [0.58, 1], [1, 1]]],
-    easeInOut: [[[0, 0], [0.42, 0], [0.58, 1], [1, 1]]],
-    bounceOut: [[[0, 0], [0.1, 0], [0.2, 0.5], [0.3, 1]],
-        [[0.3, 1], [0.4, 0.7], [0.6, 0.7], [0.7, 1]],
-        [[0.7, 1], [0.75, 0.85], [0.85, 0.85], [0.9, 1]],
-        [[0.9, 1], [0.925, 0.95], [0.975, 0.95], [1, 1]]]
+    linear: [
+        [
+            [0, 0],
+            [0.5, 0.5],
+            [0.5, 0.5],
+            [1, 1],
+        ],
+    ],
+    ease: [
+        [
+            [0, 0],
+            [0.25, 0.1],
+            [0.25, 1],
+            [1, 1],
+        ],
+    ],
+    easeIn: [
+        [
+            [0, 0],
+            [0.42, 0],
+            [1, 1],
+            [1, 1],
+        ],
+    ],
+    easeOut: [
+        [
+            [0, 0],
+            [0, 0],
+            [0.58, 1],
+            [1, 1],
+        ],
+    ],
+    easeInOut: [
+        [
+            [0, 0],
+            [0.42, 0],
+            [0.58, 1],
+            [1, 1],
+        ],
+    ],
+    bounceOut: [
+        [
+            [0, 0],
+            [0.1, 0],
+            [0.2, 0.5],
+            [0.3, 1],
+        ],
+        [
+            [0.3, 1],
+            [0.4, 0.7],
+            [0.6, 0.7],
+            [0.7, 1],
+        ],
+        [
+            [0.7, 1],
+            [0.75, 0.85],
+            [0.85, 0.85],
+            [0.9, 1],
+        ],
+        [
+            [0.9, 1],
+            [0.925, 0.95],
+            [0.975, 0.95],
+            [1, 1],
+        ],
+    ],
 };
 // Simple linear transition between two object position value could look like this:
 // [

package/lib/data/core.d.ts

@@ -63,9 +63,11 @@ export interface NodeData {
 export interface BehaviorData {
     id: string;
     type: Import;
+    label?: string;
     parent: {
         id: string;
         order: string;
+        scriptName?: string;
     };
 }
 export type EntityPropOverride = PropEntityPropOverride | ImportEntityPropOverride | ContextValueEntityPropOverride;

package/lib/inflate.js

@@ -135,6 +135,7 @@ export function createLayerClipFromData(zcomp, layer, data) {
     if (data.reverse)
         ret.defaultPlaySpeed *= -1;
     ret.defaultLoop = data.loop ?? false;
+    ret.playAtStart = data.playAtStart ?? false;
     return ret;
 }
 export function createLayerFromData(zcomp, anim, data) {

package/lib/selectors.d.ts

@@ -1,4 +1,4 @@
-import { EntityPropOverride, Import, NodeByID, ParsedImport, Props } from './data/core';
+import { BehaviorByID, EntityPropOverride, Import, NodeByID, ParsedImport, Props, ZComponentData } from './data/core';
 import * as Data from './data';
 import { Layer } from './animation';
 export declare function parseImport(i: Import): ParsedImport;
@@ -6,6 +6,8 @@ export declare function constructImport(from: string, destFile: string, imp: str
 export declare function getScriptName(n: string, requireUniqueIn: string[] | {
     [k: string]: any;
 }): string;
+export declare function getScriptNameForBehaviorLabel(zcomp: ZComponentData, nodeID: string, label: string): string;
+export declare function getScriptNameForNodeLabel(zcomp: ZComponentData, label: string): string;
 export declare function isValidVariableName(n: string): boolean;
 export declare function variableNameFromImport(imp: ParsedImport): string;
 export type EntityPropOverrideByEntityPropPath = {
@@ -23,8 +25,10 @@ export declare const typeDefinitionForComponent: (nodes: NodeByID, props: Props,
     [id: string]: {
         [id: string]: boolean;
     };
-} | undefined, url: string, layers: Data.ByID<Data.Layer>) => string;
+} | undefined, layers: Data.ByID<Data.Layer>, behaviors: BehaviorByID) => string;
 export declare function getSafeKeyName(n: string): string;
 export declare function propertyTracksByEntityID(clip: Data.Clip): {
     [id: string]: Data.PropertyTrack[];
 };
+export declare function getBehaviorBlockForNode(behaviors: BehaviorByID, behaviorIDs: string[], importMapping: Map<string, string>): string;
+export declare function importNameWithoutExt(imp: string): string;

package/lib/selectors.js

@@ -2,6 +2,7 @@ import { EntityPropOverrideType } from './data/core';
 import * as path from 'path';
 import { outputForType } from './types';
 import * as Data from './data';
+import { computeBehaviorHierarchy } from './data';
 export function parseImport(i) {
     if (typeof i !== 'string')
         return ['', ''];
@@ -107,6 +108,29 @@ export function getScriptName(n, requireUniqueIn) {
     }
     return finalname;
 }
+export function getScriptNameForBehaviorLabel(zcomp, nodeID, label) {
+    const uniques = [];
+    const behaviorsByNode = computeBehaviorHierarchy(zcomp.behaviors);
+    const nodeBehaviors = behaviorsByNode[nodeID];
+    if (nodeBehaviors) {
+        for (const behaviorID of nodeBehaviors) {
+            const behavior = zcomp.behaviors[behaviorID];
+            if (!behavior?.parent.scriptName)
+                continue;
+            uniques.push(behavior.parent.scriptName);
+        }
+    }
+    return getScriptName(label, uniques);
+}
+export function getScriptNameForNodeLabel(zcomp, label) {
+    const uniques = [];
+    for (const node of Object.values(zcomp.nodes)) {
+        if (!node?.scriptName)
+            continue;
+        uniques.push(node.scriptName);
+    }
+    return getScriptName(label, uniques);
+}
 const variableNameRegex = new RegExp(/[a-zA-Z_$][0-9a-zA-Z_$]*/);
 export function isValidVariableName(n) {
     return variableNameRegex.test(n);
@@ -161,10 +185,11 @@ export function summaryForEntityPropOverrideDestination(o) {
     }
     return '?';
 }
-export const typeDefinitionForComponent = (nodes, props, constructorProps, scriptNames, url, layers) => {
+export const typeDefinitionForComponent = (nodes, props, constructorProps, scriptNames, layers, behaviors) => {
     const importMapping = new Map();
     let indx = 0;
     let importStrings = [];
+    const behaviorsByNodeID = computeBehaviorHierarchy(behaviors);
     for (const scriptNameNodes of Object.values(scriptNames ?? {})) {
         for (const nodeID of Object.keys(scriptNameNodes)) {
             const node = nodes[nodeID];
@@ -177,6 +202,18 @@ export const typeDefinitionForComponent = (nodes, props, constructorProps, scrip
                 importMapping.set(node.type, variable);
                 indx++;
             }
+            for (const behaviorID of behaviorsByNodeID[nodeID] ?? []) {
+                const behavior = behaviors[behaviorID];
+                if (!behavior)
+                    continue;
+                if (!importMapping.has(behavior.type)) {
+                    const imp = parseImport(behavior.type);
+                    const variable = `${getScriptName(variableNameFromImport(imp), {})}_${indx.toString()}`;
+                    importStrings.push(`import { ${imp[1]} as ${variable} } from ${JSON.stringify(importNameWithoutExt(imp[0]))};`);
+                    importMapping.set(behavior.type, variable);
+                    indx++;
+                }
+            }
         }
     }
     return `import { ZComponent, ContextManager, Observable, Animation, Layer, LayerClip } from "@zcomponent/core";
@@ -199,10 +236,10 @@ declare class Comp extends ZComponent {
 ${Object.entries(scriptNames ?? {}).map(entry => {
         const values = Object.keys(entry[1]);
         if (values.length > 1) {
-            return `\t\t${entry[0]}: {${values.map(e => `${JSON.stringify(e)}: ${importMapping.get(nodes[e].type)}`).join(', ')}},`;
+            return `\t\t${entry[0]}: {${values.map(e => `${JSON.stringify(e)}: ${importMapping.get(nodes[e].type)}${getBehaviorBlockForNode(behaviors, behaviorsByNodeID[nodes[e].id] ?? [], importMapping)}`).join(', ')}},`;
         }
         else {
-            return `\t\t${entry[0]}: ${importMapping.get(nodes[values[0]].type)},`;
+            return `\t\t${entry[0]}: ${importMapping.get(nodes[values[0]].type)}${getBehaviorBlockForNode(behaviors, behaviorsByNodeID[nodes[values[0]].id] ?? [], importMapping)},`;
         }
     }).join("\n")}
 	};
@@ -287,3 +324,24 @@ export function propertyTracksByEntityID(clip) {
     }
     return ret;
 }
+export function getBehaviorBlockForNode(behaviors, behaviorIDs, importMapping) {
+    return ` & {
+			behaviors: {
+${behaviorIDs.map((entry, indx) => {
+        const behavior = behaviors[entry];
+        if (!behavior)
+            return '';
+        const type = importMapping.get(behavior.type);
+        const ret = [`\t\t\t\t${indx.toString()}: ${type},`];
+        if (behavior.parent.scriptName)
+            ret.push(`\t\t\t\t${behavior.parent.scriptName}: ${type},`);
+        return ret.join('\n');
+    }).join('\n')}
+			}
+		}`;
+}
+export function importNameWithoutExt(imp) {
+    if (imp.toLowerCase().endsWith('.ts'))
+        return imp.substring(0, imp.length - 3);
+    return imp;
+}

package/lib/zcomponent.js

@@ -62,7 +62,11 @@ export class ZComponent extends Component {
         this.animation.initialize();
         this.isConstructed = true;
         this._constructedResolve();
-        started(contextManager).then(this._updateAnimationRegistrations);
+        started(contextManager).then(() => {
+            this._updateAnimationRegistrations();
+            if (!isDesignTime(contextManager))
+                this.animation.start();
+        });
         this.register(this.animation.hasLayers, this._updateAnimationRegistrations, { bindWhenDisabled: true });
     }
     _constructorForNode(nodeId) {
@@ -179,6 +183,8 @@ export class ZComponent extends Component {
                 setCurrentZComponentConstruction(that);
                 super(contextManager, instance, constructorProps);
                 that.entityByID.set(behaviorId, this);
+                if (node?.parent?.scriptName)
+                    instance.behaviors[node.parent.scriptName] = this;
                 const props = {
                     ...(that._opts.data.entityProps?.[behaviorId] ?? {}),
                     ...(that._opts.propReplacement?.[behaviorId] ?? {}),
@@ -195,6 +201,8 @@ export class ZComponent extends Component {
             }
             dispose() {
                 that.entityByID.delete(behaviorId);
+                if (node?.parent?.scriptName)
+                    delete this.instance.behaviors[node.parent.scriptName];
                 return super.dispose();
             }
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zcomponent/core",
-  "version": "0.0.29",
+  "version": "0.0.31-beta",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",