@zcomponent/core 1.16.0-beta → 1.17.0-beta

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

package/lib/types.js

@@ -350,10 +350,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 +460,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 +508,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.17.0-beta",
   "description": "The core component model and built-in functionality for Mattercraft.",
   "main": "index.js",
   "types": "index.d.ts",