@zcomponent/core 1.9.1 → 1.11.0-beta

package/lib/types.d.ts

@@ -113,6 +113,8 @@ export interface Prop {
     order?: number;
     priority?: number;
     optional?: boolean;
+    showInUI?: boolean;
+    readonly?: boolean;
 }
 export interface DefaultChild {
     label: string;

package/lib/types.js

@@ -1,4 +1,4 @@
-import { EntityPropOverrideType } from './data/core';
+import { EntityPropOverrideType, FunctionCallType } from './data/core';
 import { getSafeKeyName } from './selectors';
 export var TypeName;
 (function (TypeName) {
@@ -138,6 +138,8 @@ export function mergeValues(a, b) {
 export function mergeProps(a, b) {
     if (a.name !== b.name)
         return;
+    if ((a.readonly && !b.readonly) || (b.readonly && !a.readonly))
+        return;
     const type = mergeTypes(a.type, b.type);
     if (!type)
         return;
@@ -154,6 +156,7 @@ export function mergeProps(a, b) {
         priority: Math.max(a.priority ?? 0, b.priority ?? 0),
         values: mergeValues(a.values, b.values),
         order: Math.min(a.order ?? 0, b.order ?? 0),
+        readonly: a.readonly,
     };
 }
 function mergeComments(a, b) {
@@ -328,6 +331,31 @@ export function isValidValueForType(def, t, allowUndefined) {
                 return true;
             return def === t.value;
         case 'function':
+            if (typeof def !== 'object')
+                return false;
+            if (def['_zfn'] !== true)
+                return false;
+            if (typeof def['args'] !== 'object')
+                return false;
+            if (def['t'] === FunctionCallType.Context) {
+                if (typeof def['imp'] !== 'string' || def['imp'].length === 0)
+                    return false;
+                if (typeof def['fn'] !== 'string' || def['fn'].length === 0)
+                    return false;
+                return true;
+            }
+            if (def['t'] === FunctionCallType.Entity) {
+                if (typeof def['entityID'] !== 'string' || def['entityID'].length === 0)
+                    return false;
+                if (typeof def['fn'] !== 'string' || def['fn'].length === 0)
+                    return false;
+                return true;
+            }
+            if (def['t'] === FunctionCallType.Import) {
+                if (typeof def['imp'] !== 'string' || def['imp'].length === 0)
+                    return false;
+                return true;
+            }
             return false;
     }
     return false;

package/lib/zcomponent.d.ts

@@ -59,8 +59,10 @@ export declare class ZComponent<RootType = any> extends Component<RootType> {
     private _constructorForNode;
     private _constructorForBehavior;
     resolveNodeID<T extends Component = Component>(id: string, type?: ConstructorForComponent<T>): T | undefined;
+    resolveEntityID<T extends Entity = Entity>(id: string): T | undefined;
     private _inflateBehaviors;
     private _wrapBehaviors;
+    private _wrapFunctionCall;
     notifyPropsChanged(entries: Map<string, Set<string>>): void;
     notifyClipsChanged(clips: Set<string>): void;
     private _initializeOverrides;

package/lib/zcomponent.js

@@ -7,8 +7,9 @@ import { isDesignTime } from './contexts/environmentcontext';
 import { isStarted, started } from './contexts/loadcontext';
 import { TagContext } from './contexts/tagcontext';
 import { computeBehaviorHierarchy, computeNodeHierarchy } from './data';
+import { Entity } from './entity';
 import { populateAnimationStructureFromData, populateAnimationTracksFromData, updateClipFromData } from './inflate';
-import { EntityPropOverrideType } from './data/core';
+import { EntityPropOverrideType, FunctionCallType } from './data/core';
 import { Observable } from './observable';
 import { setCurrentZComponentConstruction } from './zcomponentconstruction';
 export class ZComponentContext extends Context {
@@ -188,6 +189,11 @@ export class ZComponent extends Component {
                     ...(that._opts.constructorPropReplacement?.[behaviorId] ?? {}),
                     ...(that._constructorPropOverridesByEntityID.get(behaviorId) ?? {}),
                 };
+                for (const key in constructorProps) {
+                    const val = constructorProps[key];
+                    if (val !== undefined && val !== null && val['_zfn'] === true)
+                        constructorProps[key] = that._wrapFunctionCall(val);
+                }
                 setCurrentZComponentConstruction(that);
                 super(contextManager, instance, constructorProps);
                 that.entityByID.set(behaviorId, this);
@@ -227,6 +233,14 @@ export class ZComponent extends Component {
             return entity;
         return undefined;
     }
+    resolveEntityID(id) {
+        const entity = this.entityByID.get(id);
+        if (!entity)
+            return this.getZComponentInstance()?.resolveEntityID(id);
+        if (!(entity instanceof Entity))
+            return undefined;
+        return entity;
+    }
     _inflateBehaviors() {
         for (const [nodeID, impl, ctx] of this._behaviorsToInitialize) {
             this._wrapBehaviors(nodeID, impl, ctx);
@@ -248,6 +262,55 @@ export class ZComponent extends Component {
             }
         }
     }
+    _wrapFunctionCall(c) {
+        switch (c.t) {
+            case FunctionCallType.Context:
+                return () => {
+                    try {
+                        if (typeof c.imp !== 'string' || typeof c.fn !== 'string' || typeof c.args !== 'object')
+                            throw new Error('Invalid function call data');
+                        const contextConstructor = c.resolved;
+                        if (!contextConstructor)
+                            throw new Error('Unable to find context');
+                        const context = this.contextManager.get(contextConstructor);
+                        if (!context)
+                            throw new Error('Unable to get context');
+                        const func = context[c.fn];
+                        if (!func || typeof func !== 'function')
+                            throw new Error('Unable to find function on enttiy');
+                        const tf = func;
+                        const converted = [];
+                        for (const key in c.args)
+                            converted[key] = c.args[key];
+                        return tf.call(context, ...converted);
+                    }
+                    catch (err) {
+                        console.error('Unable to call context function', err);
+                    }
+                };
+            case FunctionCallType.Entity:
+                return () => {
+                    try {
+                        if (typeof c.entityID !== 'string' || typeof c.fn !== 'string' || typeof c.args !== 'object')
+                            throw new Error('Invalid function call data');
+                        const entity = this.resolveEntityID(c.entityID);
+                        if (!entity)
+                            throw new Error('Unable to find entity');
+                        const func = entity[c.fn];
+                        if (!func || typeof func !== 'function')
+                            throw new Error('Unable to find function on enttiy');
+                        const tf = func;
+                        const converted = [];
+                        for (const key in c.args)
+                            converted[key] = c.args[key];
+                        return tf.call(entity, ...converted);
+                    }
+                    catch (err) {
+                        console.error('Unable to call entity function', err);
+                    }
+                };
+        }
+    }
     notifyPropsChanged(entries) {
         for (const [entityID, propSet] of entries.entries()) {
             const entity = this.entityByID.get(entityID);
@@ -354,6 +417,8 @@ export class ZComponent extends Component {
         }
     }
     _setEntityProp(entity, prop, v) {
+        if (v !== undefined && v !== null && v['_zfn'] === true)
+            v = this._wrapFunctionCall(v);
         if (entity[prop] instanceof Observable)
             entity[prop].value = v;
         else
@@ -373,6 +438,8 @@ export class ZComponent extends Component {
             parent = parent[currentKey];
             currentKey = propPath[i];
         }
+        if (v !== undefined && v !== null && v['_zfn'] === true)
+            v = this._wrapFunctionCall(v);
         parent[currentKey] = v;
     }
     _getNodeById(id) {

package/package.json

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