@divmain/jdm-asm 0.2.1 → 0.2.3

package/src/runtime/context.ts

@@ -1,189 +0,0 @@
-// assembly/runtime/context.ts (AssemblyScript)
-import { Value, TYPE_OBJECT } from './values';
-
-/**
- * Stores cached path resolution metadata to avoid redundant string splitting
- * and prefix matching on frequently-accessed paths.
- */
-class PathResolutionCache {
-  // Cache entry: stores the matched prefix key, its length, and the split parts for a given path
-  prefixKey: string;
-  prefixLen: i32;
-  parts: string[];
-
-  constructor(prefixKey: string, prefixLen: i32, parts: string[]) {
-    this.prefixKey = prefixKey;
-    this.prefixLen = prefixLen;
-    this.parts = parts;
-  }
-}
-
-/**
- * Resolves a potentially dotted path against a data map with caching support.
- *
- * Keys like "$nodes.expression2" are stored as literal strings with dots in them,
- * not as nested objects. This function handles both cases:
- * 1. Exact key match (e.g., "$nodes.expression2")
- * 2. Nested path (e.g., "$nodes.expression2.L1" where "$nodes.expression2" is a key
- *    and "L1" is a property inside the object stored at that key)
- *
- * The algorithm finds the longest matching prefix in the data map, then navigates
- * any remaining path segments through nested object properties.
- *
- * Performance: Uses an optional cache to avoid redundant path splitting and prefix
- * matching for frequently-accessed paths within a single evaluation.
- */
-export function resolvePathInData(
-  data: Map<string, Value>,
-  path: string,
-  cache: Map<string, PathResolutionCache> | null = null,
-): Value {
-  // Check for exact key match first
-  if (data.has(path)) {
-    return data.get(path);
-  }
-
-  // If no dot, the key doesn't exist
-  if (!path.includes('.')) {
-    return Value.Null();
-  }
-
-  // Check cache if available
-  let matchedPrefixLen: i32 = 0;
-  let prefixKey: string = '';
-  let parts: string[];
-
-  if (cache !== null && cache.has(path)) {
-    // Cache hit - use cached resolution metadata AND cached parts array
-    const cached = cache.get(path);
-    prefixKey = cached.prefixKey;
-    matchedPrefixLen = cached.prefixLen;
-    parts = cached.parts;
-  } else {
-    // Cache miss - perform full path resolution
-    parts = path.split('.');
-
-    // Try progressively longer prefixes to find a matching key
-    // e.g., for "$nodes.expression2.L1", try:
-    //   1. "$nodes" (no match)
-    //   2. "$nodes.expression2" (match! then access .L1 inside)
-    let currentPrefix = '';
-    for (let i = 0; i < parts.length; i++) {
-      if (i > 0) currentPrefix += '.';
-      currentPrefix += parts[i];
-      if (data.has(currentPrefix)) {
-        matchedPrefixLen = i + 1;
-        prefixKey = currentPrefix;
-      }
-    }
-
-    // Store in cache if available (including the parts array to avoid future splits)
-    if (cache !== null) {
-      cache.set(path, new PathResolutionCache(prefixKey, matchedPrefixLen, parts));
-    }
-  }
-
-  // If no prefix matched, path doesn't exist
-  if (matchedPrefixLen == 0) {
-    return Value.Null();
-  }
-
-  // Get the value at the matched prefix
-  let current = data.get(prefixKey);
-
-  // Navigate remaining parts as object properties
-  for (let i = matchedPrefixLen; i < parts.length; i++) {
-    if (!current.isObject()) return Value.Null();
-    const obj = current.asObject();
-    const key = parts[i];
-    if (!obj.has(key)) return Value.Null();
-    current = obj.get(key);
-  }
-  return current;
-}
-
-export class Context {
-  data: Map<string, Value>;
-  // Cache for decision node results to avoid redundant evaluation. Caching prevents
-  // exponential evaluation time for DAG structures where multiple nodes reference
-  // the same upstream computation.
-  decisionResults: Map<string, Value>;
-  // Stack to track currently evaluating decisions for recursion detection
-  decisionStack: string[];
-  // When merging results, we need to know which keys are original inputs (should be
-  // preserved) vs computed outputs (may be overwritten). This prevents input shadowing.
-  inputKeys: Set<string>;
-  // Cache for path resolution to avoid redundant string splitting and prefix matching.
-  // For decisions with many field accesses (e.g., 100-rule decision table with 5 inputs
-  // per rule = 500 path lookups), this eliminates most splitting overhead.
-  pathCache: Map<string, PathResolutionCache>;
-
-  constructor(input: Map<string, Value>) {
-    this.data = input;
-    this.decisionResults = new Map<string, Value>();
-    this.decisionStack = new Array<string>();
-    this.pathCache = new Map<string, PathResolutionCache>();
-    // Store original input keys
-    this.inputKeys = new Set<string>();
-    const keys = input.keys();
-    for (let i = 0; i < keys.length; i++) {
-      this.inputKeys.add(keys[i]);
-    }
-  }
-
-  // Unlike JS Map which returns undefined for missing keys, AS Map.get() throws.
-  // We must check has() first or handle dots carefully to avoid runtime errors.
-  get(path: string): Value {
-    return resolvePathInData(this.data, path, this.pathCache);
-  }
-
-  set(path: string, value: Value): void {
-    this.data.set(path, value);
-  }
-
-  // Merge another result into this context (for passthrough mode)
-  merge(other: Map<string, Value>): void {
-    const keys = other.keys();
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      this.data.set(key, other.get(key));
-    }
-  }
-
-  // Convert the context data to a Value (for passthrough sub-decisions)
-  toValue(): Value {
-    return Value.Object(this.data);
-  }
-}
-
-/**
- * ScopedContext is a lightweight context wrapper for scoped expression evaluation.
- * Scoped evaluation (loops, sub-object navigation) needs simple Map-based get/set
- * without decision caching/recursion tracking. Separate class avoids polluting
- * Context with unnecessary state and provides clearer semantics.
- *
- * Used for:
- * - inputField scoping (expressions evaluated within a sub-object scope)
- * - executionMode: "loop" (expressions evaluated for each array item)
- *
- * Performance: Includes path caching for loop-mode expressions where the same paths
- * are accessed repeatedly across array items.
- */
-export class ScopedContext {
-  data: Map<string, Value>;
-  // Path resolution cache for frequently-accessed paths in loops
-  pathCache: Map<string, PathResolutionCache>;
-
-  constructor(data: Map<string, Value>) {
-    this.data = data;
-    this.pathCache = new Map<string, PathResolutionCache>();
-  }
-
-  get(path: string): Value {
-    return resolvePathInData(this.data, path, this.pathCache);
-  }
-
-  set(path: string, value: Value): void {
-    this.data.set(path, value);
-  }
-}