@rkmodules/rules 0.0.1

package/dist/lib/Engine/types.d.ts

@@ -0,0 +1,55 @@
+import { Tree } from "../DataTree";
+/**
+ * type definition of rule inputs and outputs
+ */
+export type NormalizedVarDef = {
+    type: string;
+    default?: any;
+    description?: string;
+    required?: boolean;
+    options?: string[];
+};
+export type VarDef = string | NormalizedVarDef;
+/**
+ * a reference to the output of an previous function call or a primitive value
+ */
+export type VarRefValue = string | number | boolean | Object;
+export type VarRef = Record<string, VarRefValue | VarRefValue[]>;
+export type RecOfTrees = Record<string, Tree<any>>;
+/**
+ * primitive node, with input and output definitions and an implementation
+ * this is similar to native functions
+ */
+export type PrimitiveFunction = {
+    name: string;
+    label?: string;
+    nodeType?: string;
+    description?: string;
+    params?: Record<string, VarDef>;
+    inputs?: Record<string, VarDef>;
+    outputs?: Record<string, VarDef>;
+    impl: (inputs: RecOfTrees, params: Record<string, any>) => Promise<RecOfTrees>;
+    mount?: (trigger: () => void) => (() => void) | void;
+};
+/**
+ * reference to another function, which can be seen as a function call
+ */
+export type FunctionCall = {
+    name: string;
+    inputs?: VarRef;
+    params?: VarRef;
+};
+/**
+ * a node that contains other nodes, with input and output definitions and references to other nodes
+ * this is similar to a function definition that only calls other functions
+ */
+export type GraphedFunction = {
+    name: string;
+    label?: string;
+    description?: string;
+    params?: Record<string, VarDef>;
+    inputs?: Record<string, VarDef>;
+    outputs?: VarRef;
+    body: Record<string, FunctionCall>;
+};
+export type AnyFunction = PrimitiveFunction | GraphedFunction;

package/dist/lib/Engine/util.d.ts

@@ -0,0 +1,7 @@
+import { Tree } from "../DataTree";
+import { VarRef } from "./types";
+export declare function isReference(value: any): value is string;
+export declare function parseReference(ref: string): string;
+export declare function uid(): string;
+export declare function getValue(obj: Record<string, any>, path: string): any;
+export declare function interpolate(inputs: VarRef, scope: Record<string, Record<string, Tree<any>>>): Record<string, Tree<any>>;

package/dist/lib/Flow/Components/Control.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+interface ControlProps {
+    value: any;
+    type: string;
+    options?: string[];
+    onChange?: (value: any) => void;
+}
+export declare function Control({ value, type, options, onChange }: ControlProps): React.JSX.Element;
+export {};

package/dist/lib/Flow/Components/GenericNode.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import { FunctionNode } from "../types";
+import { GraphedFunction, VarDef } from "../../Engine";
+interface GenericNodeProps {
+    id: string;
+    data: FunctionNode["data"];
+    selected: boolean;
+    inputs?: Record<string, VarDef>;
+    outputs?: Record<string, VarDef>;
+    params?: Record<string, VarDef>;
+    children?: React.ReactNode;
+    onChange: (fn: GraphedFunction) => void;
+}
+export declare function GenericNode({ id, data, selected, inputs, outputs, params, children, onChange, }: GenericNodeProps): React.JSX.Element;
+export {};

package/dist/lib/Flow/Components/Input.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export declare const Input: ({ name, varDef, id, data, onChange }: {
+    name: any;
+    varDef: any;
+    id: any;
+    data: any;
+    onChange: any;
+}) => React.JSX.Element;

package/dist/lib/Flow/Components/NodeContainer.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+interface NodeContainerProps {
+    id?: string;
+    label: string;
+    className?: string;
+    selected?: boolean;
+    children?: React.ReactNode;
+}
+export declare function NodeContainer({ id, label, className, selected, children, }: NodeContainerProps): React.JSX.Element;
+export {};

package/dist/lib/Flow/Components/Output.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+export declare const Output: ({ name, varDef, id }: {
+    name: any;
+    varDef: any;
+    id: any;
+}) => React.JSX.Element;

package/dist/lib/Flow/Components/Param.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export declare const Param: ({ id, name, varDef, data, onChange }: {
+    id: any;
+    name: any;
+    varDef: any;
+    data: any;
+    onChange: any;
+}) => React.JSX.Element;

package/dist/lib/Flow/Context.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { Engine, GraphedFunction } from "../Engine";
+export declare const EngineContext: React.Context<Engine>;
+export declare const useEngine: () => Engine;
+export declare const ChangeContext: React.Context<(fn: GraphedFunction) => void>;
+export declare const useChange: () => (fn: GraphedFunction) => void;

package/dist/lib/Flow/Nodes/Calc.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { NodeProps } from "@xyflow/react";
+import { FunctionNode } from "../types";
+import "katex/dist/katex.min.css";
+type MathProps = {
+    expr: string;
+    displayMode?: boolean;
+};
+export declare function MathView({ expr, displayMode }: MathProps): React.JSX.Element;
+export declare const Calc: React.MemoExoticComponent<({ id, data, selected }: NodeProps<FunctionNode>) => React.JSX.Element>;
+export {};

package/dist/lib/Flow/Nodes/Default.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { NodeProps } from "@xyflow/react";
+import { FunctionNode } from "../types";
+export declare const Default: React.MemoExoticComponent<({ id, data, selected }: NodeProps<FunctionNode>) => React.JSX.Element>;

package/dist/lib/Flow/Nodes/Log.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { NodeProps } from "@xyflow/react";
+import { FunctionNode } from "../types";
+export declare const Log: React.MemoExoticComponent<({ id, data, selected }: NodeProps<FunctionNode>) => React.JSX.Element>;

package/dist/lib/Flow/Nodes/index.d.ts

@@ -0,0 +1,5 @@
+export declare const nodeTypes: {
+    Default: import("react").MemoExoticComponent<({ id, data, selected }: import("@xyflow/react").NodeProps<import("..").FunctionNode>) => import("react").JSX.Element>;
+    Calc: import("react").MemoExoticComponent<({ id, data, selected }: import("@xyflow/react").NodeProps<import("..").FunctionNode>) => import("react").JSX.Element>;
+    Log: import("react").MemoExoticComponent<({ id, data, selected }: import("@xyflow/react").NodeProps<import("..").FunctionNode>) => import("react").JSX.Element>;
+};

package/dist/lib/Flow/index.d.ts

@@ -0,0 +1,21 @@
+import { Edge } from "@xyflow/react";
+import { GraphedFunction } from "../Engine/types";
+import React from "react";
+import { Engine } from "../Engine";
+import { FunctionNode } from "./types";
+import "@xyflow/react/dist/style.css";
+export * from "./types";
+export type PositionData = Record<string, {
+    x: number;
+    y: number;
+}>;
+export declare function createGraph(fn: GraphedFunction, engine: Engine, positions?: PositionData): {
+    nodes: FunctionNode[];
+    edges: Edge[];
+};
+interface FlowProps {
+    function: GraphedFunction;
+    engine: Engine;
+    onChange?: (fn: GraphedFunction) => void;
+}
+export declare function Flow({ function: fn, engine, onChange }: FlowProps): React.JSX.Element;

package/dist/lib/Flow/types.d.ts

@@ -0,0 +1,8 @@
+import { Node } from "@xyflow/react";
+import { GraphedFunction, VarRef } from "../Engine";
+export type FunctionNode = Node<{
+    name: string;
+    caller: GraphedFunction;
+    inputs?: VarRef;
+    params?: VarRef;
+}>;

package/dist/lib/Primitives/List/filterList.d.ts

@@ -0,0 +1,2 @@
+import { PrimitiveFunction } from "../../Engine/types";
+export declare const filterList: PrimitiveFunction;

package/dist/lib/Primitives/List/graftTree.d.ts

@@ -0,0 +1,2 @@
+import { PrimitiveFunction } from "../../Engine/types";
+export declare const graftTree: PrimitiveFunction;

package/dist/lib/Primitives/List/index.d.ts

@@ -0,0 +1,3 @@
+import { PrimitiveFunction } from "../../Engine";
+declare const primitives: Record<string, PrimitiveFunction>;
+export default primitives;

package/dist/lib/Primitives/List/listItem.d.ts

@@ -0,0 +1,2 @@
+import { PrimitiveFunction } from "../../Engine/types";
+export declare const listItem: PrimitiveFunction;

package/dist/lib/Primitives/List/listLength.d.ts

@@ -0,0 +1,2 @@
+import { PrimitiveFunction } from "../../Engine/types";
+export declare const listLength: PrimitiveFunction;

package/dist/lib/Primitives/List/trimTree.d.ts

@@ -0,0 +1,2 @@
+import { PrimitiveFunction } from "../../Engine/types";
+export declare const trimTree: PrimitiveFunction;

package/dist/lib/Primitives/Math/calc.d.ts

@@ -0,0 +1,12 @@
+import { PrimitiveFunction } from "../../Engine";
+/**
+ * TODO: need rank polymorhism on the tree item sizes
+ */
+export declare const calc: PrimitiveFunction;
+/**
+ * Return a sorted list of unbound symbol names in a MathJS expression.
+ * @param expr The expression string, e.g. "x + y"
+ * @param scope Names already defined/known (e.g. from your evaluation scope)
+ * @param extraBound Extra names to treat as bound (e.g. UI reserved words)
+ */
+export declare function getUnboundSymbols(expr: string, scope?: Record<string, unknown>, extraBound?: string[]): string[];

package/dist/lib/Primitives/Math/greaterThan.d.ts

@@ -0,0 +1,2 @@
+import { PrimitiveFunction } from "../../Engine/types";
+export declare const greaterThan: PrimitiveFunction;

package/dist/lib/Primitives/Math/index.d.ts

@@ -0,0 +1,3 @@
+import { PrimitiveFunction } from "../../Engine";
+declare const primitives: Record<string, PrimitiveFunction>;
+export default primitives;

package/dist/lib/Primitives/Math/lessThan.d.ts

@@ -0,0 +1,2 @@
+import { PrimitiveFunction } from "../../Engine/types";
+export declare const lessThan: PrimitiveFunction;

package/dist/lib/Primitives/Util/getValue.d.ts

@@ -0,0 +1,5 @@
+import { PrimitiveFunction } from "../../Engine";
+/**
+ * TODO: need rank polymorhism on the tree item sizes
+ */
+export declare const getValue: PrimitiveFunction;

package/dist/lib/Primitives/Util/index.d.ts

@@ -0,0 +1,3 @@
+import { PrimitiveFunction } from "../../Engine";
+declare const primitives: Record<string, PrimitiveFunction>;
+export default primitives;

package/dist/lib/Primitives/Util/log.d.ts

@@ -0,0 +1,2 @@
+import { PrimitiveFunction } from "../../Engine/types";
+export declare const log: PrimitiveFunction;

package/dist/lib/Primitives/Util/value.d.ts

@@ -0,0 +1,5 @@
+import { PrimitiveFunction } from "../../Engine";
+/**
+ * value primitive function
+ */
+export declare const value: PrimitiveFunction;

package/dist/lib/Primitives/index.d.ts

@@ -0,0 +1,2 @@
+import { PrimitiveFunction } from "../Engine/types";
+export declare const primitives: Record<string, PrimitiveFunction>;

package/dist/lib/hooks/useFunction.d.ts

@@ -0,0 +1,18 @@
+import { Engine, GraphedFunction } from "../Engine";
+/**
+ * using functions
+ *
+ * in React context
+ * - 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 await engine.run(fn, inputs) to run the function and get the result
+ */
+export declare function useFunction(engine: Engine, fn: GraphedFunction, mount?: boolean): {
+    fn: import("../Engine").PrimitiveFunction;
+    run: (inputs?: Record<string, any>) => Promise<any>;
+    result: any;
+};

package/dist/lib/hooks/useVariable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * scope restricts the variable scope, for example to a view id
+ * @param scope
+ * @param name
+ */
+export declare const useVariable: <T = any>(scope: string, name: string, initial: T, persist?: boolean) => [T, (t: T) => void];

package/package.json

@@ -0,0 +1,56 @@
+{
+    "name": "@rkmodules/rules",
+    "version": "0.0.1",
+    "main": "dist/index.js",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": "./dist/index.js",
+        "./styles.css": "./dist/index.css"
+    },
+    "scripts": {
+        "test": "jest",
+        "test:watch": "jest --watch",
+        "watch": "tsc -w --project tsconfig-pack.json",
+        "build:ts": "tsc --project tsconfig-pack.json",
+        "build": "npm run rollup",
+        "rollup": "rm -rf dist && rollup -c",
+        "prepare": "npm run rollup",
+        "dev": "next dev"
+    },
+    "author": "rikkert@rikkertkoppes.com",
+    "license": "ISC",
+    "description": "",
+    "peerDependencies": {
+        "next": ">=14.2.3",
+        "react": ">=19.1.1",
+        "react-dom": ">=19.1.1"
+    },
+    "dependencies": {
+        "@rkmodules/use-inner": "^1.0.3",
+        "@xyflow/react": "^12.8.3",
+        "classnames": "^2.5.1",
+        "katex": "^0.16.22",
+        "mathjs": "^14.6.0",
+        "zustand": "^5.0.7"
+    },
+    "devDependencies": {
+        "@rkmodules/use-selection": "^0.10.0",
+        "@rollup/plugin-commonjs": "^28.0.6",
+        "@rollup/plugin-typescript": "^12.1.4",
+        "@types/jest": "^30.0.0",
+        "@types/node": "24.3.0",
+        "@types/react": "^19.1.1",
+        "jest": "^30.0.5",
+        "next": "^15.4.7",
+        "react": "^19.1.1",
+        "react-dom": "^19.1.1",
+        "rollup": "^4.46.3",
+        "rollup-plugin-exclude-dependencies-from-bundle": "^1.1.24",
+        "rollup-plugin-postcss": "^4.0.2",
+        "ts-jest": "^29.4.1",
+        "typescript": "^5.9.2"
+    }
+}

package/readme.md

@@ -0,0 +1,66 @@
+TODO:
+
+-   [ ] 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
+
+Math
+
+-   [x] lessThan
+-   [x] greaterThan
+
+Text
+
+-   formatting
+-   text replacement
+
+grasshopper investigation
+
+value
+
+# using functions
+
+in React context
+
+-   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
+
+# 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
+
+-   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