@zcomponent/core 1.16.0-beta → 1.18.0-beta

package/lib/behaviors/EmitComponentPropEvent.d.ts

@@ -0,0 +1,21 @@
+import { ActionBehavior } from '../actionbehavior';
+/**
+ * Calls emit on an event that's a prop of this ZComponent
+ *
+ * @zbehavior
+ * @zicon function
+ * @zgroup Actions
+ */
+export declare class EmitComponentPropEvent extends ActionBehavior {
+    /**
+     * The event to emit
+     * @zprop
+     * @ztype function-emit-component-prop-event
+     */
+    eventToEmit: () => any;
+    /**
+     * @zui
+     * @zprop
+     */
+    perform(): void;
+}

package/lib/behaviors/EmitComponentPropEvent.js

@@ -0,0 +1,19 @@
+import { ActionBehavior } from '../actionbehavior';
+import { registerBehaviorRunAtDesignTime } from '../behavior';
+/**
+ * Calls emit on an event that's a prop of this ZComponent
+ *
+ * @zbehavior
+ * @zicon function
+ * @zgroup Actions
+ */
+export class EmitComponentPropEvent extends ActionBehavior {
+    /**
+     * @zui
+     * @zprop
+     */
+    perform() {
+        this.eventToEmit();
+    }
+}
+registerBehaviorRunAtDesignTime(EmitComponentPropEvent);

package/lib/data/core.d.ts

@@ -100,7 +100,8 @@ export interface ContextValueEntityPropOverride extends BaseEntityPropOverride {
 export declare enum FunctionCallType {
     Entity = "entity",
     Context = "context",
-    Import = "import"
+    Import = "import",
+    EmitComponentEvent = "emitcomponentevent"
 }
 export interface BaseFunctionCall {
     _zfn: true;
@@ -125,4 +126,8 @@ export interface ImportFunctionCall extends BaseFunctionCall {
     t: FunctionCallType.Import;
     resolved?: any;
 }
-export type FunctionCall = EntityFunctionCall | ContextFunctionCall | ImportFunctionCall;
+export interface EmitComponentEventFunctionCall extends BaseFunctionCall {
+    prop: string;
+    t: FunctionCallType.EmitComponentEvent;
+}
+export type FunctionCall = EntityFunctionCall | ContextFunctionCall | ImportFunctionCall | EmitComponentEventFunctionCall;

package/lib/data/core.js

@@ -9,4 +9,5 @@ export var FunctionCallType;
     FunctionCallType["Entity"] = "entity";
     FunctionCallType["Context"] = "context";
     FunctionCallType["Import"] = "import";
+    FunctionCallType["EmitComponentEvent"] = "emitcomponentevent";
 })(FunctionCallType || (FunctionCallType = {}));

package/lib/selectors.js

@@ -319,7 +319,7 @@ export const typeDefinitionForComponent = (nodes, props, constructorProps, scrip
             }
         }
     }
-    return `import { ZComponent, ContextManager, Observable, Animation, Layer, LayerClip } from "@zcomponent/core";
+    return `import { ZComponent, ContextManager, Observable, Animation, Layer, LayerClip, Event } from "@zcomponent/core";
 
 ${importStrings.join('\n')}
 
@@ -429,6 +429,9 @@ function getJSDocForProp(prop) {
  * @returns A string representing the TypeScript output for the property.
  */
 function typeOutputForProp(prop) {
+    if (prop.type.name === 'event')
+        return `${getJSDocForProp(prop)}
+	public ${prop.name}: ${outputForType(prop.type, true)};`;
     return `${getJSDocForProp(prop)}
 	public ${prop.name}: Observable<${outputForType(prop.type, true)}>;`;
 }

package/lib/types.d.ts

@@ -124,11 +124,11 @@ export interface FunctionType extends BaseType {
 }
 /**
  * Type definition for an event type.
- *
- * This interface extends BaseType and is used specifically for defining an event type.
  */
 export interface EventType extends BaseType {
     name: 'event';
+    children: Type[];
+    names?: string[];
 }
 /** Internal use comment is sufficient for EntityType
  * @internal
@@ -164,7 +164,8 @@ export declare enum TypeHint {
     'time-milliseconds' = "time-milliseconds",
     'time-hertz' = "time-hertz",
     'emailaddress' = "emailaddress",
-    'url' = "url"
+    'url' = "url",
+    'function-emit-component-prop-event' = "function-emit-component-prop-event"
 }
 /**
  * Enumeration of values types used in a values definition.

package/lib/types.js

@@ -43,6 +43,7 @@ export var TypeHint;
     TypeHint["time-hertz"] = "time-hertz";
     TypeHint["emailaddress"] = "emailaddress";
     TypeHint["url"] = "url";
+    TypeHint["function-emit-component-prop-event"] = "function-emit-component-prop-event";
 })(TypeHint || (TypeHint = {}));
 /**
  * Enumeration of values types used in a values definition.
@@ -350,10 +351,19 @@ export function mergeTypes(a, b) {
                 comments: mergeComments(a.comments ?? [], b.comments ?? []),
             };
         case 'event':
+            const children = [];
+            for (let i = 0; i < a.children.length; i++) {
+                const merged = mergeTypes(a.children[i], b.children[i]);
+                if (!merged)
+                    return undefined;
+                children.push(merged);
+            }
             return {
                 name: a.name,
                 typeHint,
+                children,
                 comments: mergeComments(a.comments ?? [], b.comments ?? []),
+                names: mergeTupleNames(a, b),
             };
     }
 }
@@ -451,6 +461,11 @@ export function isValidValueForType(def, t, allowUndefined) {
                     return false;
                 return true;
             }
+            if (def['t'] === FunctionCallType.EmitComponentEvent) {
+                if (typeof def['prop'] !== 'string' || def['prop'].length === 0)
+                    return false;
+                return true;
+            }
             return false;
     }
     return false;
@@ -494,7 +509,10 @@ function getBasicType(t) {
         case 'function':
             return `(${t.args.map(entry => `${entry.name}: ${outputForType(entry.type)}`).join(', ')}) => ${t.ret ? outputForType(t.ret) : 'void'}`;
         case 'event':
-            return 'Event';
+            if (Array.isArray(t.names) && t.names.length === t.children.length) {
+                return `Event<[${t.children.map((c, indx) => `${getSafeKeyName(t.names[indx])}: ${outputForType(c)}`).join(', ')}]>`;
+            }
+            return `Event<[${t.children.map(c => outputForType(c)).join(', ')}]>`;
     }
 }
 /**

package/lib/zcomponent.js

@@ -13,6 +13,7 @@ import { populateAnimationStructureFromData, populateAnimationTracksFromData, up
 import { EntityPropOverrideType, FunctionCallType } from './data/core';
 import { Observable } from './observable';
 import { setCurrentZComponentConstruction } from './zcomponentconstruction';
+import { Event } from './event';
 export class ZComponentContext extends Context {
     /**
      * Creates an instance of ZComponentContext.
@@ -370,6 +371,25 @@ export class ZComponent extends Component {
                         console.error('Unable to call entity function', err);
                     }
                 };
+            case FunctionCallType.EmitComponentEvent:
+                return () => {
+                    try {
+                        if (typeof c.prop !== 'string' || typeof c.args !== 'object')
+                            throw new Error('Invalid function call data');
+                        const evt = this[c.prop];
+                        if (!evt)
+                            throw new Error('Unable to find component event');
+                        if (!(evt instanceof Event))
+                            throw new Error('Component property is not an event');
+                        const converted = [];
+                        for (const key in c.args)
+                            converted[key] = c.args[key];
+                        evt.emit.call(evt, ...converted);
+                    }
+                    catch (err) {
+                        console.error('Unable to emit component event', err);
+                    }
+                };
         }
     }
     /**
@@ -484,7 +504,10 @@ export class ZComponent extends Component {
     _initializeComponentProps() {
         const componentProps = this._opts.data.props ?? {};
         for (const prop of Object.values(componentProps)) {
-            this[prop.name] = new Observable(prop.default);
+            if (prop.type.name === 'event')
+                this[prop.name] = new Event();
+            else
+                this[prop.name] = new Observable(prop.default);
         }
     }
     _setEntityProp(entity, prop, v) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zcomponent/core",
-  "version": "1.16.0-beta",
+  "version": "1.18.0-beta",
   "description": "The core component model and built-in functionality for Mattercraft.",
   "main": "index.js",
   "types": "index.d.ts",