@rkmodules/rules 0.0.25 → 0.0.26

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

@@ -2,7 +2,7 @@ import { Tree } from "../DataTree";
 import { GraphedFunction, NormalizedVarDef, PrimitiveFunction, AnyFunction, VarDef, VarRef, FunctionCall } from "./types";
 export * from "./types";
 export * from "./util";
-interface Ref {
+export interface Ref {
     name: string;
     path: string;
     parts: string[];
@@ -47,8 +47,8 @@ export declare class Engine {
     fireEvent(eventName: string, event: EngineEvent): void;
     run(node: AnyFunction, inputs?: VarRef): any;
     getFunction(name: string): PrimitiveFunction | undefined;
-    applyNodeDelete(fn: GraphedFunction, nodeIds: string[]): GraphedFunction;
-    applyEdgeDelete(fn: GraphedFunction, fromNode: string, toNode: string, fromField: string, toField: string): GraphedFunction;
-    applyNodeAdd(fn: GraphedFunction, nodeName: string, callback?: (newNode: FunctionCall, id: string) => void): GraphedFunction;
-    applyNodeConnect(fn: GraphedFunction, fromNode: string, toNode: string, fromField: string, toField: string): GraphedFunction;
+    applyNodeDelete(oldFn: GraphedFunction, nodeIds: string[]): GraphedFunction;
+    applyEdgeDelete(oldFn: GraphedFunction, fromNode: string, toNode: string, fromField: string, toField: string): GraphedFunction;
+    applyNodeAdd(oldFn: GraphedFunction, nodeName: string, callback?: (newNode: FunctionCall, id: string) => void): GraphedFunction;
+    applyNodeConnect(oldFn: GraphedFunction, fromNode: string, toNode: string, fromField: string, toField: string): GraphedFunction;
 }

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

@@ -2,12 +2,17 @@ import React from "react";
 import { XYPosition } from "@xyflow/react";
 import { GraphedFunction } from "../Engine/types";
 import { Engine } from "../Engine";
+import { Updater } from "./types";
 import "./style/xyflow.css";
 export * from "./types";
+/**
+ * goal: this component should only be responsible for updating the inner node graph, it should call the onChange handler
+ * on any change, but not rerender when the given function changes, as it slows down the interface drastically
+ */
 interface FlowProps {
     function: GraphedFunction;
     engine: Engine;
-    onChange?: (fn: GraphedFunction) => void;
+    onChange?: (updater: Updater<GraphedFunction>) => void;
     onClick?: (event: React.MouseEvent, position: XYPosition) => void;
     onSelect?: (ids: string[]) => void;
 }

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

@@ -1,8 +1,7 @@
 import { Node } from "@xyflow/react";
-import { GraphedFunction, PrimitiveFunction, VarDef, VarRef } from "../Engine";
+import { PrimitiveFunction, VarDef, VarRef } from "../Engine";
 export type FunctionNode = Node<{
     name: string;
-    caller: GraphedFunction;
     inputs?: VarRef;
     params?: VarRef;
     inputDefs: Record<string, VarDef>;
@@ -14,3 +13,4 @@ export type NodeDropItem = {
     name: string;
     fn: PrimitiveFunction;
 };
+export type Updater<T> = (oldValue: T) => T;

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

@@ -1,4 +1,3 @@
-import React from "react";
 import { Edge } from "@xyflow/react";
 import { Engine, GraphedFunction } from "../Engine";
 import { FunctionNode } from "../Flow";
@@ -6,15 +5,26 @@ export type PositionData = Record<string, {
     x: number;
     y: number;
 }>;
-type CreateGraphOptions = {
+/**
+ * TODO: replace this whole thing with a zustand state
+ * - whenever the outer function changes, update the inner node graph
+ * - but do so useing shallow comparison, so only update changed nodes
+ * - also store the node positions in the zustand state, so they are not lost on rerender
+ *
+ * - state is not persisted in local storage, that is the job of the outer function variable in the page
+ */
+interface FlowOptions {
     dragHandle?: string;
-    setNodes: React.Dispatch<React.SetStateAction<FunctionNode[]>>;
-    setEdges: React.Dispatch<React.SetStateAction<Edge[]>>;
-    onChange?: (fn: GraphedFunction) => void;
-};
-export declare function createGraph(fn: GraphedFunction, engine: Engine, positions?: PositionData, options?: CreateGraphOptions): {
+    positions?: PositionData;
+    onDataChange?: (id: string) => (newData: Partial<FunctionNode["data"]>) => void;
+}
+/**
+ * creates a flow state and provides handlers to update nodes and edges
+ */
+export declare function useFlow(fn: GraphedFunction, engine: Engine, options: FlowOptions): {
     nodes: FunctionNode[];
     edges: Edge[];
+    setNodes: (updater: (nodes: FunctionNode[]) => FunctionNode[]) => void;
+    setEdges: (updater: (edges: Edge[]) => Edge[]) => void;
 };
-export declare function useFlow(fn: GraphedFunction, engine: Engine, options: CreateGraphOptions): void;
 export {};

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

@@ -3,6 +3,6 @@ type Point = {
     x: number;
     y: number;
 };
-export declare function usePositions(fn: GraphedFunction): [Record<string, Point>, (t: Record<string, Point>) => void];
+export declare function usePositions(fn: GraphedFunction): [Record<string, Point>, (t: Record<string, Point> | ((oldValue: Record<string, Point>) => Record<string, Point>)) => void];
 export declare function useUpdatePositions(fn: GraphedFunction): (id: string, position: Point) => void;
 export {};

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

@@ -1,6 +1,8 @@
+type Updater<T> = (oldValue: T) => T;
 /**
  * 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];
+export declare const useVariable: <T = any>(scope: string, name: string, initial: T, persist?: boolean) => [T, (t: T | Updater<T>) => void];
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rkmodules/rules",
-    "version": "0.0.25",
+    "version": "0.0.26",
     "main": "dist/index.js",
     "types": "./dist/index.d.ts",
     "files": [