@rkmodules/rules 0.0.167 → 0.0.169

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

@@ -1,5 +1,5 @@
 import { Tree } from "../DataTree";
-import { GraphedFunction, NormalizedVarDef, PrimitiveFunction, AnyFunction, VarDef, VarRef, RecOfTrees, FunctionCall } from "./types";
+import { GraphedFunction, NormalizedVarDef, PrimitiveFunction, AnyFunction, VarDef, VarRef, RecOfTrees, FunctionCall, ExecutionContext } from "./types";
 export * from "./types";
 export * from "./util";
 export interface Ref {
@@ -10,16 +10,8 @@ export interface Ref {
     refField: string;
 }
 export declare function normalizeVarDef(varDef: VarDef): NormalizedVarDef;
-export declare function getReferences(inputs: VarRef): Ref[];
+export declare function getReferences(inputs: Record<string, VarRef>): Ref[];
 export declare function topSort(fn: GraphedFunction): GraphedFunction;
-export interface ExecutionContext {
-    scope: Record<string, Record<string, Tree<any>>>;
-    calls: Record<string, FunctionCall>;
-    inputs: Record<string, Record<string, Tree<any>>>;
-    params: Record<string, Record<string, any>>;
-    timings: Record<string, number>;
-    activations: Record<string, boolean>;
-}
 export interface EngineStartEvent {
     name: string;
     fn: string;
@@ -36,14 +28,14 @@ export interface EngineEndEvent extends EngineStartEvent {
 }
 export type EngineEvent = EngineStartEvent | EngineEndEvent;
 export type EngineEventName = "result" | "functionCall" | "functionResult";
-export declare class Engine {
+export declare class Engine<Env extends Record<string, any> = Record<string, any>> {
     private fnIndex;
     private listeners;
     private cache;
     private cacheMiss;
     private context;
-    env: Record<string, any>;
-    constructor(morePrimitives?: Record<string, PrimitiveFunction>, env?: Record<string, any>);
+    env: Env;
+    constructor(morePrimitives?: Record<string, PrimitiveFunction>, env?: Env);
     private checkCache;
     private runGraph;
     /**
@@ -61,8 +53,8 @@ export declare class Engine {
     fireEvent(eventName: "result", event: EngineEndEvent): void;
     fireEvent(eventName: "functionCall", event: EngineStartEvent): void;
     fireEvent(eventName: "functionResult", event: EngineEndEvent): void;
-    run(node: AnyFunction, inputs?: VarRef): any;
-    runDetailed(node: AnyFunction, inputs?: VarRef): Promise<EngineEndEvent>;
+    run(node: AnyFunction, inputs?: Record<string, VarRef>): any;
+    runDetailed(node: AnyFunction, inputs?: Record<string, VarRef>): Promise<EngineEndEvent>;
     getFunction(name: string): PrimitiveFunction | undefined;
     applyNodeDelete(oldFn: GraphedFunction, nodeIds: string[]): GraphedFunction;
     applyEdgeDelete(oldFn: GraphedFunction, fromNode: string, toNode: string, fromField: string, toField: string): GraphedFunction;

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

@@ -1,4 +1,4 @@
-import { Engine, ExecutionContext } from ".";
+import { Engine } from ".";
 import { Tree } from "../DataTree";
 /**
  * type definition of rule inputs and outputs
@@ -16,12 +16,17 @@ export type NormalizedVarDef = {
     allowEmpty?: boolean;
     controlProps?: Record<string, any>;
 };
+/**
+ * description of an input for a function, it is either a string indicating the type,
+ * or a normalized variable definition, containing detailed metadata about the input like
+ * type, label, options, min, max etc, see NormalizedVarDef
+ */
 export type VarDef = string | NormalizedVarDef;
+export type VarRefPrimitive = string | number | boolean | Object;
 /**
  * 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 VarRef = VarRefPrimitive | VarRefPrimitive[];
 export type RecOfTrees = Record<string, Tree<any>>;
 /**
  * primitive node, with input and output definitions and an implementation
@@ -47,8 +52,8 @@ export type PrimitiveFunction = {
 export type FunctionCall = {
     name: string;
     label?: string;
-    inputs?: VarRef;
-    params?: VarRef;
+    inputs?: Record<string, VarRef>;
+    params?: Record<string, VarRef>;
     inputDefs?: Record<string, VarDef>;
     outputDefs?: Record<string, VarDef>;
 };
@@ -62,7 +67,15 @@ export type GraphedFunction = {
     description?: string;
     params?: Record<string, VarDef>;
     inputs?: Record<string, VarDef>;
-    outputs?: VarRef;
+    outputs?: Record<string, VarRef>;
     body: Record<string, FunctionCall>;
 };
 export type AnyFunction = PrimitiveFunction | GraphedFunction;
+export interface ExecutionContext {
+    scope: Record<string, Record<string, Tree<any>>>;
+    calls: Record<string, FunctionCall>;
+    inputs: Record<string, Record<string, Tree<any>>>;
+    params: Record<string, Record<string, any>>;
+    timings: Record<string, number>;
+    activations: Record<string, boolean>;
+}

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

@@ -7,4 +7,4 @@ 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 safeName(name: string): string;
-export declare function interpolate(inputs: VarRef, scope: Record<string, Record<string, Tree<any>>>): Record<string, Tree<any>>;
+export declare function interpolate(inputs: Record<string, VarRef>, scope: Record<string, Record<string, Tree<any>>>): Record<string, Tree<any>>;

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

@@ -9,7 +9,7 @@ type FlowContextState = {
     prompts?: Prompts;
 };
 export declare const FlowContext: React.Context<FlowContextState>;
-export declare const useEngine: () => Engine;
+export declare const useEngine: () => Engine<Record<string, any>>;
 export declare const useControls: () => {};
 export declare const useGraphedFunction: () => GraphedFunction;
 export declare const usePrompts: () => {

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

@@ -4,9 +4,9 @@ export type FunctionNode = Node<{
     name: string;
     label: string;
     description?: string;
-    inputs?: VarRef;
-    params?: VarRef;
-    outputs?: VarRef;
+    inputs?: Record<string, VarRef>;
+    params?: Record<string, VarRef>;
+    outputs?: Record<string, VarRef>;
     inputDefs: Record<string, VarDef>;
     paramDefs: Record<string, VarDef>;
     outputDefs: Record<string, VarDef>;

package/package.json

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

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

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