driftjs-shared 0.0.1

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "driftjs-shared",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./dist/index-es.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index-es.js",
+      "require": "./dist/index-cjs.js"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "driftjs-compiler": "0.0.1"
+  },
+  "devDependencies": {
+    "typescript": "^7.0.2",
+    "vite": "^8.1.5",
+    "vitest": "^4.1.10"
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "vitest run"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,3 @@
+/** Maximum registers allowed per Virtual Machine execution frame */
+export const MAX_REGISTERS = 256;
+

package/src/evaluator.ts

@@ -0,0 +1,101 @@
+import { setScopeValue, inScopeChain } from './scope.js';
+import { astToJS } from 'driftjs-compiler';
+
+/**
+ * Safely resolves an iterable object or array.
+ */
+export function resolveIterable(rawIter: any): any[] {
+  if (Array.isArray(rawIter)) return rawIter;
+  if (rawIter && typeof rawIter[Symbol.iterator] === 'function') {
+    return Array.from(rawIter);
+  }
+  return [];
+}
+
+/**
+ * Executes a pre-compiled function string stored on AST constant nodes.
+ */
+export function executePrecompiledFn(node: any, scope: Record<string, any>, declaredVars?: Set<string>): any {
+  if (typeof node.__drift_fn__ === 'function') {
+    return node.__drift_fn__(scope, declaredVars, setScopeValue, inScopeChain, resolveIterable);
+  }
+  if (!node._executableFn) {
+    node._executableFn = typeof node.__drift_fn__ === 'string'
+      ? new Function('return (' + node.__drift_fn__ + ')')()
+      : node.__drift_fn__;
+  }
+  return node._executableFn(scope, declaredVars, setScopeValue, inScopeChain, resolveIterable);
+}
+
+/**
+ * Evaluates any JS expression (AST node, pre-compiled wrapper, function, or primitive).
+ */
+export function evaluateExpression(node: any, scope: Record<string, any>, declaredVars?: Set<string>): any {
+  if (node === null || node === undefined) return node;
+
+  if (typeof node === 'function') {
+    return node(scope, declaredVars, setScopeValue, inScopeChain, resolveIterable);
+  }
+
+  if (typeof node === 'object' && node !== null && '__drift_fn__' in node) {
+    return executePrecompiledFn(node, scope, declaredVars);
+  }
+
+  if (typeof node !== 'object' || node === null) {
+    return node;
+  }
+
+  const codeStr = astToJS(node);
+  if (!codeStr || codeStr.trim().length === 0) {
+    return undefined;
+  }
+
+  let executableFn: any;
+  try {
+    executableFn = new Function('scope', 'declaredVars', 'setScopeValue', 'inScopeChain', 'resolveIterable', 'return (' + codeStr + ')');
+  } catch {
+    executableFn = new Function('scope', 'declaredVars', 'setScopeValue', 'inScopeChain', 'resolveIterable', codeStr);
+  }
+
+  return executableFn(scope, declaredVars, setScopeValue, inScopeChain, resolveIterable);
+}
+
+/**
+ * Resolves constant or variable values against scope.
+ */
+export function resolveValue(val: any, scope: Record<string, any>, declaredVars?: Set<string>): any {
+  if (val === null || val === undefined) return val;
+  if (typeof val === 'string') return inScopeChain(scope, val) ? scope[val] : val;
+  if (typeof val === 'object' && (val.type || '__drift_fn__' in val || typeof val._executableFn === 'function')) {
+    return evaluateExpression(val, scope, declaredVars);
+  }
+  return val;
+}
+
+/**
+ * Safely unwraps an imported component module (handling ESM default exports,
+ * CompiledModule wrappers, and program objects).
+ */
+export function resolveComponentModule(raw: any): any | null {
+  if (!raw || typeof raw !== 'object') return null;
+  if (Array.isArray(raw.bytecode) || ArrayBuffer.isView(raw.bytecode)) return raw;
+  if (raw.program && (Array.isArray(raw.program.bytecode) || ArrayBuffer.isView(raw.program.bytecode))) return raw.program;
+  if (raw.default) return resolveComponentModule(raw.default);
+  if (raw.compiledModule) return resolveComponentModule(raw.compiledModule);
+  return null;
+}
+
+/**
+ * Evaluates a props specification object (mapping prop keys to static values or expression ASTs)
+ * against a VM scope, returning a plain JavaScript props object.
+ */
+export function evaluatePropsSpec(propsSpec: Record<string, any> | null | undefined, scope: Record<string, any>, declaredVars?: Set<string>): Record<string, any> {
+  if (!propsSpec || typeof propsSpec !== 'object') return {};
+  const res: Record<string, any> = {};
+  for (const key of Object.keys(propsSpec)) {
+    if (key === '__drift_props__') continue;
+    const rawVal = propsSpec[key];
+    res[key] = evaluateExpression(rawVal, scope, declaredVars);
+  }
+  return res;
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from '../types/index.js';
+export * from './constants.js';
+export * from './scope.js';
+export * from './evaluator.js';
+export * from './interpreter.js';

package/src/interpreter.ts

@@ -0,0 +1,27 @@
+import { evaluateExpression, executePrecompiledFn } from './evaluator.js';
+import { setScopeValue } from './scope.js';
+
+/**
+ * Interprets a block of Acorn AST statements (used by <script> AST and functions).
+ */
+export function executeBlockStatement(statements: any, scope: Record<string, any>, declaredVars?: Set<string>): any {
+  let result: any;
+  if (!statements) return result;
+
+  if (typeof statements === 'function') {
+    return statements(scope, declaredVars, setScopeValue);
+  }
+
+  if (typeof statements === 'object' && statements !== null && '__drift_fn__' in statements) {
+    return executePrecompiledFn(statements, scope, declaredVars);
+  }
+
+  if (Array.isArray(statements)) {
+    for (const stmt of statements) {
+      result = evaluateExpression(stmt, scope, declaredVars);
+    }
+  } else if (statements && typeof statements === 'object') {
+    result = evaluateExpression(statements, scope, declaredVars);
+  }
+  return result;
+}

package/src/scope.ts

@@ -0,0 +1,75 @@
+/**
+ * Sets a variable in scope, updating parent scope if it exists higher in prototype chain.
+ */
+export function setScopeValue(targetScope: Record<string, any>, name: string, val: any): void {
+  if (!targetScope || typeof targetScope !== 'object') return;
+
+  let curr: any = targetScope;
+  let setOn: any = null;
+  const dirtyFns: Set<(name: string) => void> = new Set();
+
+  // 1. Traverse targetScope's prototype chain to find which scope object owns `name`
+  while (curr && curr !== Object.prototype) {
+    if (Object.prototype.hasOwnProperty.call(curr, name)) {
+      curr[name] = val;
+      setOn = curr;
+      break;
+    }
+    curr = Object.getPrototypeOf(curr);
+  }
+
+  // 2. If `name` was not found on any prototype in the chain, declare it as an own property on targetScope
+  if (!setOn) {
+    targetScope[name] = val;
+    setOn = targetScope;
+  }
+
+  // 3. Collect dirty notification functions from targetScope up to setOn
+  let scan: any = targetScope;
+  while (scan && scan !== Object.prototype) {
+    if (typeof scan.__drift_mark_dirty__ === 'function') {
+      dirtyFns.add(scan.__drift_mark_dirty__);
+    }
+    if (scan === setOn) {
+      break;
+    }
+    scan = Object.getPrototypeOf(scan);
+  }
+
+  // 4. Trigger dirty marking on all affected scope VMs
+  for (const fn of dirtyFns) {
+    try {
+      fn(name);
+    } catch {
+      // ignore errors
+    }
+  }
+}
+
+/**
+ * Writes back declared variables from function scope to enclosing target scope.
+ */
+export function syncDeclaredVars(fromScope: Record<string, any>, toScope: Record<string, any>, declaredVars?: Set<string>): void {
+  if (!declaredVars) return;
+  for (const name of declaredVars) {
+    if (Object.prototype.hasOwnProperty.call(fromScope, name)) {
+      setScopeValue(toScope, name, fromScope[name]);
+    }
+  }
+}
+
+/**
+ * Safely checks if a property exists on scope or any of its parent scopes,
+ * stopping before Object.prototype to prevent prototype pollution / scope hijacking.
+ */
+export function inScopeChain(scope: any, name: string): boolean {
+  if (!scope || typeof scope !== 'object') return false;
+  let curr: any = scope;
+  while (curr && curr !== Object.prototype) {
+    if (Object.prototype.hasOwnProperty.call(curr, name)) {
+      return true;
+    }
+    curr = Object.getPrototypeOf(curr);
+  }
+  return false;
+}

package/tests/utils.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import {
+  evaluateExpression,
+  executeBlockStatement,
+  setScopeValue,
+  syncDeclaredVars,
+  resolveIterable,
+  MAX_REGISTERS,
+} from '../src/index.js';
+
+describe('driftjs-shared Module', () => {
+  it('exports MAX_REGISTERS constant equal to 256', () => {
+    expect(MAX_REGISTERS).toBe(256);
+  });
+
+  it('evaluates binary, logical, and member expressions', () => {
+    const scope = { user: { age: 25 }, threshold: 20 };
+    const expr = {
+      type: 'BinaryExpression',
+      operator: '>',
+      left: {
+        type: 'MemberExpression',
+        object: { type: 'Identifier', name: 'user' },
+        property: { type: 'Identifier', name: 'age' },
+      },
+      right: { type: 'Identifier', name: 'threshold' },
+    };
+
+    expect(evaluateExpression(expr, scope)).toBe(true);
+  });
+
+  it('sets scope value up the prototype chain', () => {
+    const parentScope = { count: 0 };
+    const childScope = Object.create(parentScope);
+
+    setScopeValue(childScope, 'count', 5);
+    expect(parentScope.count).toBe(5);
+  });
+
+  it('resolves iterables cleanly', () => {
+    expect(resolveIterable([1, 2, 3])).toEqual([1, 2, 3]);
+    expect(resolveIterable(new Set(['a', 'b']))).toEqual(['a', 'b']);
+    expect(resolveIterable(null)).toEqual([]);
+  });
+
+  it('executes block statements and updates scope', () => {
+    const scope = { val: 10 };
+    const statements = [
+      {
+        type: 'ExpressionStatement',
+        expression: {
+          type: 'AssignmentExpression',
+          operator: '=',
+          left: { type: 'Identifier', name: 'val' },
+          right: { type: 'Literal', value: 42 },
+        },
+      },
+    ];
+
+    executeBlockStatement(statements, scope);
+    expect(scope.val).toBe(42);
+  });
+
+  it('prevents prototype pollution & scope lookup hijacking for built-in Object properties', () => {
+    const scope = { name: 'Alice' };
+    const exprToString = { type: 'Identifier', name: 'toString' };
+    const exprValueOf = { type: 'Identifier', name: 'valueOf' };
+    const exprConstructor = { type: 'Identifier', name: 'constructor' };
+
+    expect(evaluateExpression(exprToString, scope)).toBeUndefined();
+    expect(evaluateExpression(exprValueOf, scope)).toBeUndefined();
+    expect(evaluateExpression(exprConstructor, scope)).toBeUndefined();
+
+    // User-declared toString override should resolve correctly
+    const customScope = { toString: 'Custom String' };
+    expect(evaluateExpression(exprToString, customScope)).toBe('Custom String');
+  });
+});

package/types/index.ts

@@ -0,0 +1,3 @@
+export interface BaseVMExecutionOptions {
+  readonly scope?: Record<string, any>;
+}

package/vite.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite';
+import path from 'path';
+
+export default defineConfig({
+  build: {
+    lib: {
+      entry: path.resolve(__dirname, 'src/index.ts'),
+      name: 'DriftUtils',
+      fileName: (format) => `index-${format}.js`,
+    },
+    rollupOptions: {
+      external: [],
+    },
+  },
+});