@rkmodules/rules 0.0.176 → 0.0.177

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

@@ -34,8 +34,12 @@ export interface EngineEndEvent extends EngineStartEvent {
     endTime: number;
     duration: number;
 }
-export type EngineEvent = EngineStartEvent | EngineEndEvent;
-export type EngineEventName = "result" | "functionCall" | "functionResult";
+export interface EngineFunctionBuiltEvent {
+    name: string;
+    fn: PrimitiveFunction;
+}
+export type EngineEvent = EngineStartEvent | EngineEndEvent | EngineFunctionBuiltEvent;
+export type EngineEventName = "result" | "functionCall" | "functionResult" | "functionBuilt";
 export declare class Engine<Env extends Record<string, any> = Record<string, any>> {
     private fnIndex;
     private graphDefinitions;
@@ -66,9 +70,11 @@ export declare class Engine<Env extends Record<string, any> = Record<string, any
     build(node: AnyFunction, id?: string): PrimitiveFunction;
     mount(node: PrimitiveFunction, inputs?: Record<string, VarRef>, options?: RunOptions): void | (() => void) | undefined;
     getContext(): ExecutionContext | null;
+    subscribe(eventName: "functionBuilt", listener: (event: EngineFunctionBuiltEvent) => void): () => void;
     subscribe(eventName: "result", listener: (event: EngineEndEvent) => void): () => void;
     subscribe(eventName: "functionCall", listener: (event: EngineStartEvent) => void): () => void;
     subscribe(eventName: "functionResult", listener: (event: EngineEndEvent) => void): () => void;
+    fireEvent(eventName: "functionBuilt", event: EngineFunctionBuiltEvent): void;
     fireEvent(eventName: "result", event: EngineEndEvent): void;
     fireEvent(eventName: "functionCall", event: EngineStartEvent): void;
     fireEvent(eventName: "functionResult", event: EngineEndEvent): void;

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

@@ -0,0 +1,40 @@
+import { Edge } from "@xyflow/react";
+import { Engine, GraphedFunction } from "../Engine";
+import type { FunctionNode } from "../Flow";
+export type PositionData = Record<string, {
+    x: number;
+    y: number;
+}>;
+export interface FlowOptions {
+    dragHandle?: string;
+    positions?: PositionData;
+    onDataChange?: (id: string) => (newData: Partial<FunctionNode["data"]>) => void;
+    onIOChange?: (callback: (fn: GraphedFunction) => Partial<GraphedFunction>) => void;
+}
+/**
+ * gets the source and target node and field from an edge by de-referencing the handles
+ * the handles are in the format `${nodeId}-${fieldName}`
+ * returns an object with the source node id, target node id, source field name and target field name
+ */
+export declare function deRefEdgeHandle(handle: string): {
+    node: string;
+    field: string;
+};
+interface FlowState {
+    engine: Engine | null;
+    fn: GraphedFunction | null;
+    options: FlowOptions;
+    nodes: Record<string, FunctionNode>;
+    edges: Edge[];
+    setNodes: (updater: (nodes: FunctionNode[]) => FunctionNode[]) => void;
+    setEdges: (updater: (edges: Edge[]) => Edge[]) => void;
+    setFn: (fn: GraphedFunction, options: FlowOptions) => void;
+    refreshFunctions: (name?: string) => void;
+    init: (fn: GraphedFunction, engine: Engine, options: FlowOptions) => void;
+}
+/**
+ * flow state stores nodes and edges for the flow graph these can be updated when the function changes
+ * using setFn
+ */
+export declare const createFlowStore: () => import("zustand/vanilla").StoreApi<FlowState>;
+export {};

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

@@ -1,31 +1,11 @@
-import { Edge } from "@xyflow/react";
 import { Engine, GraphedFunction } from "../Engine";
-import { FunctionNode } from "../Flow";
-export type PositionData = Record<string, {
-    x: number;
-    y: number;
-}>;
-export interface FlowOptions {
-    dragHandle?: string;
-    positions?: PositionData;
-    onDataChange?: (id: string) => (newData: Partial<FunctionNode["data"]>) => void;
-    onIOChange?: (callback: (fn: GraphedFunction) => Partial<GraphedFunction>) => void;
-}
-/**
- * gets the source and target node and field from an edge by de-referencing the handles
- * the handles are in the format `${nodeId}-${fieldName}`
- * returns an object with the source node id, target node id, source field name and target field name
- */
-export declare function deRefEdgeHandle(handle: string): {
-    node: string;
-    field: string;
-};
-/**
- * creates a flow state and provides handlers to update nodes and edges
- */
+import { FlowOptions } from "./flowState";
+export { deRefEdgeHandle } from "./flowState";
+export type { FlowOptions, PositionData } from "./flowState";
+/** Creates isolated editor state and observes definitions used by its nodes. */
 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;
+    nodes: import("../Flow").FunctionNode[];
+    edges: import("@xyflow/react").Edge[];
+    setNodes: (updater: (nodes: import("../Flow").FunctionNode[]) => import("../Flow").FunctionNode[]) => void;
+    setEdges: (updater: (edges: import("@xyflow/react").Edge[]) => import("@xyflow/react").Edge[]) => void;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rkmodules/rules",
-    "version": "0.0.176",
+    "version": "0.0.177",
     "main": "dist/index.cjs.js",
     "module": "dist/index.esm.mjs",
     "types": "./dist/index.d.ts",