callable nodes now default for functions (by proxy) else specified

Author: joshbrew

examples/basics/graph/index.ts

@@ -38,7 +38,7 @@ let roots = {
                 __operator:'multiply',
                 __args:['__input',5] //structure inputs for the operator on this level, '__input' or '__output' will place the input argument here
             } as GraphNodeProperties
-        }
+        },
     } as GraphNodeProperties,
 
     verboseGraphSequence:{ //same as graphSequence using functions
@@ -52,7 +52,8 @@ let roots = {
                 },
                 __args:['__input',5]
             } 
-        }
+        },
+        __callable:true
     } as GraphNodeProperties,
 
     //let's make a node that listens to the output of other nodes
@@ -77,8 +78,6 @@ console.log('Graph instance:', graph);
 
 
 
-
-
 let args = [1,2,3,4,5];
 
 let result1 = new Promise((res) => {
@@ -92,28 +91,36 @@ graph.run('graphSequence', ...args);
 
 
 
+
 let result3 = graph.run('nodeSyntax', ...args);
 let result2 = graph.run('nativeJSSyntax', ...args);
-let node = graph.get('nodeSyntax');
-let result4 = node(...args); //nodes are now callable.
 //lets remove a node and then try to run it on the graph again
 let removed = graph.remove('nativeJSSyntax');
 let result_undefined = graph.run('nativeJSSyntax', ...args);
 console.log('result after removal should be undefined:', result_undefined);
 
 
+let node = graph.get('verboseGraphSequence');
+
+let result4 = new Promise((res) => {
+    let sub = graph.subscribe('verboseGraphSequence.result', (output)=>{ 
+        graph.unsubscribe('verboseGraphSequence.result', sub);
+        res(output);
+    });
+}); 
 
+node(...args); //this sequences is callable
 
 
-result1.then((result) => {
+Promise.all([result1,result4]).then((results) => {
     document.body.insertAdjacentHTML('afterbegin', `
         <div>
             Node Run Results should match:
             <div style='margin-left:10px'>
                 Graph Node Syntax: ${result3}<br/>
                 Native JS Syntax: ${result2}<br/>
-                Graph Sequence Syntax: ${result}<br/>
-                Callable Syntax: ${result4}<br/>
+                Graph Sequence Syntax: ${results[0]}<br/>
+                Callable Syntax: ${results[1]}<br/>
             </div>
         </div>
     `);

src/core/Graph.ts

@@ -19,6 +19,7 @@ export type GraphNodeProperties = {
         [key:string]:any
     },
     __args?:any[], //can structure input arguments, include '__result' when generically calling operators for where to pass the original input in in a set of arguments
+    __callable?:boolean, //we can have the graphnode return itself as a callable function with private properties
     [key:string]:any
 }
 
@@ -85,9 +86,8 @@ export class Callable extends Function {
 
 }
 
-
 //this is a scope
-export class GraphNode extends Callable {
+export class GraphNode {
 
     __node:{
         tag:string,
@@ -114,9 +114,35 @@ export class GraphNode extends Callable {
     [key:string]:any
 
     //pass GraphNodeProperties, functions, or tags of other nodes
-    constructor(properties:any, parent?:{[key:string]:any}, graph?:Graph) {
-        super();
+    constructor(properties:GraphNodeProperties, parent?:{[key:string]:any}, graph?:Graph) {
+        //super();
         this.__setProperties(properties,parent,graph);
+
+        // Check if the properties are a function or denote the GraphNode to be callable (but all properties private!!)
+        if (typeof properties === 'function' || properties.__callable) { //assuming operator is defined
+            const callableInstance = new Callable();
+            callableInstance.__call = (...args) => this.__operator(...args);
+
+            // Create a proxy to delegate function calls to callableInstance and properties to this
+            const proxy = new Proxy(callableInstance, { //experimental
+                get: (target, prop, receiver) => {
+                    if (Reflect.has(this, prop)) {
+                        return Reflect.get(this, prop, receiver);
+                    }
+                    return Reflect.get(target, prop, receiver);
+                },
+                set: (target, prop, value, receiver) => {
+                    if (Reflect.has(this, prop)) {
+                        return Reflect.set(this, prop, value, receiver);
+                    }
+                    return Reflect.set(target, prop, value, receiver);
+                }
+            });
+            Object.setPrototypeOf(proxy,this); //pass instanceof checks
+
+            //@ts-ignore
+            return proxy;
+        }
     }
 
     __setProperties = (properties, parent, graph) => {
@@ -345,7 +371,7 @@ export class GraphNode extends Callable {
             let sub;
 
             let k = subInput ? this.__node.unique+'.'+key+'input' : this.__node.unique+'.'+key;
-            if(typeof callback === 'function' && !(callback as GraphNode)?.__node) 
+            if(typeof callback === 'function' && !(callback as any)?.__node) 
                 sub = subscribeToFunction(k, (callback, target) => (target ? target : callback), callback as (...res:any)=>void)
             else if((callback as GraphNode)?.__node) sub = subscribeToFunction(k, 
                 (callback, target) => (target ? target : (callback as GraphNode).__node.unique),
@@ -369,7 +395,7 @@ export class GraphNode extends Callable {
 
             let k = subInput ? this.__node.unique+'input' : this.__node.unique;
 
-            if(typeof callback === 'function' && !(callback as GraphNode)?.__node) sub = subscribeToFunction(k, (callback, target) => (target ? target : callback), callback as (...res:any)=>void)
+            if(typeof callback === 'function' && !(callback as any)?.__node) sub = subscribeToFunction(k, (callback, target) => (target ? target : callback), callback as (...res:any)=>void)
             else if((callback as GraphNode)?.__node) {
                 sub = subscribeToFunction(k, 
                     (callback, target) => target ? target : (callback as GraphNode).__node.unique,
@@ -421,8 +447,6 @@ export class GraphNode extends Callable {
             }
         }
 
-        this.__call = ((...args) => { return this.__operator(...args); });
-
         return this.__operator;
     }
 
@@ -1282,7 +1306,7 @@ export class Graph {
                 }
             } else {
                 if(typeof onEvent === 'string') onEvent = this.__node.nodes.get(onEvent).__operator; 
-                if(typeof onEvent === 'function' && !(onEvent as GraphNode)?.__node) sub = this.__node.state.subscribeEvent(nodeEvent, onEvent as (...res:any)=>void);
+                if(typeof onEvent === 'function' && !(onEvent as any)?.__node) sub = this.__node.state.subscribeEvent(nodeEvent, onEvent as (...res:any)=>void);
             }
         }
         return sub;
@@ -1462,7 +1486,6 @@ let objProps = Object.getOwnPropertyNames(Object.getPrototypeOf({}));
 
 
 
-
 
 //   class AnotherCallable extends Callable {
 //     constructor() {

src/services/worker/WorkerCanvas.ts

@@ -1,5 +1,5 @@
 //provide routes for applying canvases to workers
-import { GraphNode } from '../../core/Graph';
+
 import { proxyElementWorkerRoutes, initProxyElement } from './ProxyListener';
 
 declare var WorkerGlobalScope;