@rkmodules/rules 0.0.156 → 0.0.157

package/package.json

@@ -1,13 +1,14 @@
 {
     "name": "@rkmodules/rules",
-    "version": "0.0.156",
+    "version": "0.0.157",
     "main": "dist/index.cjs.js",
-    "module": "dist/index.esm.js",
+    "module": "dist/index.esm.mjs",
     "types": "./dist/index.d.ts",
+    "type": "module",
     "files": [
-        "dist/index.esm.js",
+        "dist/index.esm.mjs",
         "dist/index.cjs.js",
-        "dist/index.esm.js.map",
+        "dist/index.esm.mjs.map",
         "dist/index.cjs.js.map",
         "dist/index.d.ts",
         "dist/index.esm.css",
@@ -17,7 +18,7 @@
     ],
     "exports": {
         ".": {
-            "import": "./dist/index.esm.js",
+            "import": "./dist/index.esm.mjs",
             "require": "./dist/index.cjs.js",
             "types": "./dist/index.d.ts"
         },

package/readme.md

@@ -15,6 +15,8 @@ A function definition is just a json object. It can be assembled together via co
 ```ts
 const testFunction: GraphedFunction = {
     name: "test",
+    label: "optional label",
+    description: "optional description",
     body: {
         myVal: {
             name: "value",
@@ -32,12 +34,20 @@ const testFunction: GraphedFunction = {
 };
 ```
 
+### Inputs, params and outputs
+
+A function may also define `params`, `inputs` and `outputs` to indicate how to call the function and what it returns. This allows to create custom functions and to use them in others
+
+## Specifying primitives
+
+A primitive is a function definition that also had code
+
 We get back to function definitions later
 
 ## Running the function
 
--   build all the custom functions
--   run the one you need
+- build all the custom functions
+- run the one you need
 
 ## use in react
 
@@ -45,9 +55,9 @@ We get back to function definitions later
 
 ## editor
 
--   Create an instance of the rules engine
--   create a function to work with
--   use the `<Flow>` component to create the editor
+- Create an instance of the rules engine
+- create a function to work with
+- use the `<Flow>` component to create the editor
 
 ```tsx
 const engine = new Engine({
@@ -74,33 +84,33 @@ export default function MyComponent() {
 
 TODO:
 
--   [ ] filtering of lists
-    -   document grasshopper nodes
-    -   build them
--   [ ] set value
--   [ ] inspection
-    -   run time
-    -   running flag
-    -   intermediate results
+- [ ] filtering of lists
+    - document grasshopper nodes
+    - build them
+- [ ] set value
+- [ ] inspection
+    - run time
+    - running flag
+    - intermediate results
 
 Components / functions
 
 List
 
--   [x] listItem
--   [x] listLength
--   [x] graftTree
--   [x] trimTree
+- [x] listItem
+- [x] listLength
+- [x] graftTree
+- [x] trimTree
 
 Math
 
--   [x] lessThan
--   [x] greaterThan
+- [x] lessThan
+- [x] greaterThan
 
 Text
 
--   formatting
--   text replacement
+- formatting
+- text replacement
 
 grasshopper investigation
 
@@ -110,31 +120,30 @@ value
 
 in React context
 
--   use useFunction. This will build the function, mount it if needed and provides a run function.
+- use useFunction. This will build the function, mount it if needed and provides a run function.
 
 in Vanilla context
 
--   use engine.build(fn) to build the function
--   use engine.mount(fn) to mount the function (if it has a mount function)
--   use engine.run(fn, inputs) to run the function
+- use engine.build(fn) to build the function
+- use engine.mount(fn) to mount the function (if it has a mount function)
+- use engine.run(fn, inputs) to run the function
 
 # considerations
 
 For Supa Lipu we have quite a lot of functions that need to be called on various events
 
--   when propobjects are updated / created / deleted.
-
-    -   currently, each propobject has its own engine and 1 single rule. This is fired when the object is mutated
-    -   all functions need to be propobjects as well, then referenced in various places
-    -   the engine needs to be global, so that functions can reference each other
-        -   for these references, we need propobject refs, to that dependency functions are loaded
-    -   in useObjectMutation, we fire an event such that mounted eventlisteners can react
+- when propobjects are updated / created / deleted.
+    - currently, each propobject has its own engine and 1 single rule. This is fired when the object is mutated
+    - all functions need to be propobjects as well, then referenced in various places
+    - the engine needs to be global, so that functions can reference each other
+        - for these references, we need propobject refs, to that dependency functions are loaded
+    - in useObjectMutation, we fire an event such that mounted eventlisteners can react
 
--   we need deep references. On change, oldProps and changedProps are passed in as an object. So we need
-    -   primitives to getValue and setValue
-    -   [x] reference strings that can directly reference deeper objects to eliminate the need for getValue
--   [x] also need to think about data tree handling for outputs
+- we need deep references. On change, oldProps and changedProps are passed in as an object. So we need
+    - primitives to getValue and setValue
+    - [x] reference strings that can directly reference deeper objects to eliminate the need for getValue
+- [x] also need to think about data tree handling for outputs
 
 # Entries
 
--   in finance I had filterLine(on, match) function that filters return a boolean if any of the lines match. This is a hardcoded solition, which is ok for finance. But we might come up with something more generic
+- in finance I had filterLine(on, match) function that filters return a boolean if any of the lines match. This is a hardcoded solition, which is ok for finance. But we might come up with something more generic