@knotx/decorators 0.2.4 → 0.2.6

package/dist/index.cjs

@@ -5,92 +5,94 @@ const rxjs = require('rxjs');
 const lodashEs = require('lodash-es');
 const jsxRuntime = require('@knotx/jsx/jsx-runtime');
 
-function requireEngine(plugin) {
-  const engineSymbol = core.getSymbol("engine");
-  if (!Reflect.has(plugin, engineSymbol)) {
-    Reflect.set(plugin, engineSymbol, new rxjs.BehaviorSubject(null));
-  }
-  return Reflect.get(plugin, engineSymbol);
+function getEngine() {
+  return Reflect.get(this, core.getSymbol("engine")).value;
+}
+function subscribeEngine(callback) {
+  this.subscriptions.push(Reflect.get(this, core.getSymbol("engine")).subscribe((engine) => {
+    if (!engine)
+      return;
+    callback(engine);
+  }));
+}
+function pushSubscription(callback) {
+  this.subscriptions.push(callback);
+}
+function createBehaviorSubject(plugin, key, value) {
+  Reflect.set(plugin, key, new rxjs.BehaviorSubject(value));
+  pushSubscription.call(plugin, () => {
+    var _a;
+    return (_a = Reflect.get(plugin, key)) == null ? void 0 : _a.complete();
+  });
+  return true;
+}
+function getPropertyBehaviorSubjectKey(key) {
+  return `__${key}$__`;
+}
+function mergePluginHookFunction(...[key, newFunction]) {
+  const original = this[key];
+  this[key] = (...args) => {
+    original == null ? void 0 : original.apply(this, args);
+    newFunction.apply(this, args);
+  };
 }
 
 function edgeOperator() {
-  return function(_target, { name, static: isStatic, private: isPrivate, addInitializer }) {
-    if (isStatic || isPrivate) {
+  return function(_, context) {
+    if (context.static) {
       return;
     }
-    addInitializer(function() {
-      const operator = Reflect.get(this, name);
-      if (typeof operator !== "function") {
-        throw new TypeError("Edge operator must be a function");
-      }
-      requireEngine(this).subscribe((engine) => {
-        if (!engine)
-          return;
-        const boundOperator = operator.bind(this);
-        Reflect.set(this, name, (...args) => {
-          const operations = boundOperator(...args);
-          if (Array.isArray(operations)) {
+    context.addInitializer(function() {
+      const original = this[context.name];
+      subscribeEngine.call(this, (engine) => {
+        this[context.name] = (...args) => {
+          const operations = original.apply(this, args);
+          if (Array.isArray(operations) && operations.length > 0) {
             engine.dispatchEdgeOperation({
               type: "batch",
               operations
             });
           }
           return operations;
-        });
+        };
       });
     });
   };
 }
 
-const edgePipeSymbol = Symbol("edgePipe");
 function edgePipe() {
-  return function(_target, { name, static: isStatic, private: isPrivate, addInitializer }) {
-    if (isStatic || isPrivate) {
+  return function(_, context) {
+    if (context.static) {
       return;
     }
-    addInitializer(function() {
-      const pipeFactory = Reflect.get(this, name);
-      if (typeof pipeFactory !== "function") {
-        throw new TypeError("Edge pipe must be a function");
-      }
-      requireEngine(this).subscribe((engine) => {
-        if (!engine)
-          return;
-        const pipe = pipeFactory.call(this);
-        engine.addEdgePipe(pipe);
-        if (!this[edgePipeSymbol]) {
-          this[edgePipeSymbol] = {};
-        }
-        this[edgePipeSymbol][name] = pipe;
+    context.addInitializer(function() {
+      subscribeEngine.call(this, (engine) => {
+        pushSubscription.call(this, engine.addEdgePipe(this[context.name]()));
       });
     });
   };
 }
 
 function edgeType(type) {
-  return function(_target, { name, static: isStatic, private: isPrivate, addInitializer }) {
-    if (isStatic || isPrivate) {
+  return function(_, context) {
+    if (context.static) {
       return;
     }
-    addInitializer(function() {
-      const renderer = Reflect.get(this, name);
-      if (typeof renderer !== "function") {
-        throw new TypeError("Edge renderer must be a function");
-      }
-      requireEngine(this).subscribe((engine) => engine == null ? void 0 : engine.registerEdgeRenderer(type, renderer.bind(this)));
+    context.addInitializer(function() {
+      subscribeEngine.call(this, (engine) => {
+        pushSubscription.call(this, engine.registerEdgeRenderer(type, this[context.name].bind(this)));
+      });
     });
   };
 }
 
 function injectData(context, engineKey, selector) {
   context.addInitializer(function() {
-    const engine$ = requireEngine(this);
     Reflect.defineProperty(this, context.name, {
       get() {
-        const engine = engine$.value;
-        if (!engine) {
+        const engine = getEngine.call(this);
+        if (!engine)
           return void 0;
-        }
         const engineKey$ = `${String(engineKey)}$`;
         const paths = lodashEs.get(engine, engineKey$) ? [engineKey$] : [engineKey];
         return core.Runtime.getInstance().getValue(engine, { paths, selector });
@@ -102,7 +104,7 @@ function injectData(context, engineKey, selector) {
 function injectMethod(context, methodKey) {
   context.addInitializer(function() {
     Reflect.set(this, context.name, (...methodArgs) => {
-      const engine = requireEngine(this).value;
+      const engine = getEngine.call(this);
       const engineMethod = engine == null ? void 0 : engine[methodKey];
       if (!engineMethod || typeof engineMethod !== "function") {
         throw new Error(`Engine method ${String(methodKey)} not found`);
@@ -114,10 +116,9 @@ function injectMethod(context, methodKey) {
 
 function injectPluginData(context, pluginName, property, selector) {
   context.addInitializer(function() {
-    const engine$ = requireEngine(this);
     Reflect.defineProperty(this, context.name, {
       get() {
-        const engine = engine$.value;
+        const engine = getEngine.call(this);
         if (!engine) {
           return void 0;
         }
@@ -231,7 +232,6 @@ function isBehaviorSubject(value) {
 function injectable(context, injectableSelector) {
   const injectableStateSymbol = Symbol(`injectable:${String(context.name)}`);
   context.addInitializer(function() {
-    const engine$ = requireEngine(this);
     Reflect.set(this, injectableStateSymbol, {
       initialized: false,
       accessRecord: null,
@@ -243,7 +243,7 @@ function injectable(context, injectableSelector) {
     });
     Reflect.defineProperty(this, context.name, {
       get() {
-        const engine = engine$.value;
+        const engine = getEngine.call(this);
         if (!engine) {
           return void 0;
         }
@@ -312,46 +312,20 @@ function createInjectProxy(...presets) {
 }
 const inject = createInjectProxy();
 
-function register(property) {
+function layer(layer2, offset) {
   return function(_, context) {
-    if (context.kind !== "field" && context.kind !== "getter") {
+    if (context.static) {
       return;
     }
     context.addInitializer(function() {
-      const subject = new rxjs.BehaviorSubject(Reflect.get(this, context.name));
-      const engine$ = requireEngine(this);
-      engine$.subscribe((engine) => engine == null ? void 0 : engine.registerPluginData(this.name, property, subject));
-      Reflect.defineProperty(this, context.name, {
-        get() {
-          const engine = engine$.value;
-          if (!engine) {
-            return void 0;
-          }
-          return core.Runtime.getInstance().getValue(engine, { paths: ["_pluginDataContainer", this.name, property] });
-        },
-        set(value) {
-          if (context.kind === "field") {
-            subject.next(value);
-          }
-        }
-      });
+      var _a;
+      const layers = (_a = Reflect.get(this, core.getSymbol("layer"))) != null ? _a : {};
+      layers[context.name] = { layer: layer2, offset };
+      Reflect.set(this, core.getSymbol("layer"), layers);
     });
   };
 }
 
-function layer(layer2, offset) {
-  return function(_target, { name, kind, static: isStatic, private: isPrivate, addInitializer }) {
-    if (kind === "method" && typeof name === "string" && !isStatic && !isPrivate) {
-      addInitializer(function() {
-        var _a;
-        const layers = (_a = Reflect.get(this, core.getSymbol("layer"))) != null ? _a : {};
-        layers[name] = { layer: layer2, offset };
-        Reflect.set(this, core.getSymbol("layer"), layers);
-      });
-    }
-  };
-}
-
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -437,160 +411,169 @@ function ContainerListener({
   return container.width > 0 && container.height > 0 ? /* @__PURE__ */ jsxRuntime.jsx(Wrapper, { container, children }) : null;
 }
 function panel(position, offset) {
-  return function(_target, { name, kind, static: isStatic, private: isPrivate, addInitializer }) {
-    if (kind === "method" && typeof name === "string" && !isStatic && !isPrivate) {
-      addInitializer(function() {
-        var _a;
-        const layers = (_a = Reflect.get(this, core.getSymbol("layer"))) != null ? _a : {};
-        const originalRender = Reflect.get(this, name);
-        Reflect.set(this, name, function(...args) {
-          const result = originalRender == null ? void 0 : originalRender.apply(this, args);
-          const engine = requireEngine(this).value;
-          if (!engine || !result) {
-            return result;
-          }
-          return /* @__PURE__ */ jsxRuntime.jsx(
-            ContainerListener,
-            {
-              getContainer: () => core.Runtime.getInstance().getValue(engine, { paths: ["container$"] }),
-              position,
-              offset,
-              children: result
-            }
-          );
-        });
-        layers[name] = { layer: core.Layer.Foreground };
-        Reflect.set(this, core.getSymbol("layer"), layers);
-      });
+  return function(_, context) {
+    if (context.static) {
+      return;
     }
+    layer(core.Layer.Foreground)(_, context);
+    context.addInitializer(function() {
+      const originalRender = this[context.name];
+      this[context.name] = () => {
+        const result = originalRender == null ? void 0 : originalRender.apply(this);
+        const engine = getEngine.call(this);
+        if (!result || !engine) {
+          return result;
+        }
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          ContainerListener,
+          {
+            getContainer: () => (
+              // TODO (boen): fixhack
+              core.Runtime.getInstance().getValue(engine, { paths: ["container$"] })
+            ),
+            position,
+            offset,
+            children: result
+          }
+        );
+      };
+    });
   };
 }
 
 function nodeOperator() {
-  return function(_target, { name, static: isStatic, private: isPrivate, addInitializer }) {
-    if (isStatic || isPrivate) {
+  return function(_, context) {
+    if (context.static) {
       return;
     }
-    addInitializer(function() {
-      const operator = Reflect.get(this, name);
-      if (typeof operator !== "function") {
-        throw new TypeError("Node operator must be a function");
-      }
-      requireEngine(this).subscribe((engine) => {
-        if (!engine)
-          return;
-        const boundOperator = operator.bind(this);
-        Reflect.set(this, name, (...args) => {
-          const operations = boundOperator(...args);
-          if (Array.isArray(operations)) {
+    context.addInitializer(function() {
+      const original = this[context.name];
+      subscribeEngine.call(this, (engine) => {
+        this[context.name] = (...args) => {
+          const operations = original.apply(this, args);
+          if (Array.isArray(operations) && operations.length > 0) {
             engine.dispatchNodeOperation({
               type: "batch",
               operations
             });
           }
           return operations;
-        });
+        };
       });
     });
   };
 }
 
-const nodePipeSymbol = Symbol("nodePipe");
 function nodePipe() {
-  return function(_target, { name, static: isStatic, private: isPrivate, addInitializer }) {
-    if (isStatic || isPrivate) {
+  return function(_, context) {
+    if (context.static) {
       return;
     }
-    addInitializer(function() {
-      const pipeFactory = Reflect.get(this, name);
-      if (typeof pipeFactory !== "function") {
-        throw new TypeError("Node pipe must be a function");
-      }
-      requireEngine(this).subscribe((engine) => {
-        if (!engine)
-          return;
-        const pipe = pipeFactory.call(this);
-        engine.addNodePipe(pipe);
-        if (!this[nodePipeSymbol]) {
-          this[nodePipeSymbol] = {};
-        }
-        this[nodePipeSymbol][name] = pipe;
+    context.addInitializer(function() {
+      subscribeEngine.call(this, (engine) => {
+        pushSubscription.call(this, engine.addNodePipe(this[context.name]()));
       });
     });
   };
 }
 
 function nodeType(type) {
-  return function(_target, { name, static: isStatic, private: isPrivate, addInitializer }) {
-    if (isStatic || isPrivate) {
+  return function(_, context) {
+    if (context.static) {
       return;
     }
-    addInitializer(function() {
-      const renderer = Reflect.get(this, name);
-      if (typeof renderer !== "function") {
-        throw new TypeError("Node renderer must be a function");
+    context.addInitializer(function() {
+      subscribeEngine.call(this, (engine) => {
+        pushSubscription.call(this, engine.registerNodeRenderer(type, this[context.name].bind(this)));
+      });
+    });
+  };
+}
+
+function observable() {
+  return function(_, context) {
+    if (context.static || typeof context.name !== "string") {
+      return;
+    }
+    context.addInitializer(function() {
+      const behaviorKey = getPropertyBehaviorSubjectKey(context.name);
+      if (createBehaviorSubject(this, behaviorKey, this[context.name])) {
+        subscribeEngine.call(this, (engine) => {
+          Reflect.defineProperty(this, context.name, {
+            get() {
+              return core.Runtime.getInstance().getValue(engine, {
+                paths: [],
+                matcher: () => this[behaviorKey]
+              });
+            },
+            set(value) {
+              this[behaviorKey].next(value);
+            }
+          });
+        });
       }
-      requireEngine(this).subscribe((engine) => engine == null ? void 0 : engine.registerNodeRenderer(type, renderer.bind(this)));
     });
   };
 }
 
-function OnInit(originalMethod, context) {
-  if (context.kind !== "method") {
-    console.warn("OnInit decorator can only be applied to methods");
-    return;
-  }
+function config() {
+  return function(_, context) {
+    if (context.static) {
+      return;
+    }
+    observable()(_, context);
+    context.addInitializer(function() {
+      const updateConfig = (config2) => {
+        this[context.name] = config2;
+      };
+      mergePluginHookFunction.call(this, "onInit", updateConfig);
+      mergePluginHookFunction.call(this, "onConfigChange", updateConfig);
+    });
+  };
+}
+
+function OnInit(_, context) {
   context.addInitializer(function() {
-    this.onInit = (config) => {
-      originalMethod.call(this, config);
-    };
+    mergePluginHookFunction.call(this, "onInit", this[context.name]);
   });
 }
-function OnDestroy(originalMethod, context) {
-  if (context.kind !== "method") {
-    console.warn("OnDestroy decorator can only be applied to methods");
-    return;
-  }
+function OnDestroy(_, context) {
   context.addInitializer(function() {
-    this.onDestroy = () => {
-      originalMethod.call(this);
-    };
+    mergePluginHookFunction.call(this, "onDestroy", this[context.name]);
   });
 }
-function OnConfigChange(originalMethod, context) {
-  if (context.kind !== "method") {
-    console.warn("OnConfigChange decorator can only be applied to methods");
-    return;
-  }
+function OnConfigChange(_, context) {
   context.addInitializer(function() {
-    this.onConfigChange = (config) => {
-      originalMethod.call(this, config);
-    };
+    mergePluginHookFunction.call(this, "onConfigChange", this[context.name]);
   });
 }
 
-function observable() {
+function register(property) {
   return function(_, context) {
-    if (context.kind !== "field") {
+    if (context.static) {
       return;
     }
+    observable()(_, context);
     context.addInitializer(function() {
-      const subject = new rxjs.BehaviorSubject(Reflect.get(this, context.name));
-      const engine$ = requireEngine(this);
-      Reflect.defineProperty(this, context.name, {
-        get() {
-          const engine = engine$.value;
-          if (!engine) {
-            return subject.value;
-          }
-          return core.Runtime.getInstance().getValue(engine, {
-            paths: [],
-            matcher: () => subject
-          });
-        },
-        set(value) {
-          subject.next(value);
-        }
+      subscribeEngine.call(this, (engine) => {
+        engine.registerPluginData(this.name, property, this[getPropertyBehaviorSubjectKey(context.name)]);
+      });
+    });
+  };
+}
+
+function tool(description, params) {
+  return function(_, context) {
+    if (context.static) {
+      return;
+    }
+    context.addInitializer(function() {
+      subscribeEngine.call(this, (engine) => {
+        engine.registerPluginTool(this.name, context.name, {
+          description,
+          params,
+          func: this[context.name].bind(this)
+        });
       });
     });
   };
@@ -599,6 +582,7 @@ function observable() {
 exports.OnConfigChange = OnConfigChange;
 exports.OnDestroy = OnDestroy;
 exports.OnInit = OnInit;
+exports.config = config;
 exports.createPanelWrapper = createPanelWrapper;
 exports.edgeOperator = edgeOperator;
 exports.edgePipe = edgePipe;
@@ -611,3 +595,4 @@ exports.nodeType = nodeType;
 exports.observable = observable;
 exports.panel = panel;
 exports.register = register;
+exports.tool = tool;