@cuxt/sandboxjs 0.1.0

package/build/eval.js

@@ -0,0 +1,205 @@
+import { createFunction, createFunctionAsync } from './executor.js';
+import parse, { lispifyFunction } from './parser.js';
+export function createEvalContext() {
+    return {
+        sandboxFunction,
+        sandboxAsyncFunction,
+        sandboxedEval,
+        sandboxedSetTimeout,
+        sandboxedSetInterval,
+        sandboxedClearTimeout,
+        sandboxedClearInterval,
+        lispifyFunction,
+    };
+}
+function SB() { }
+export function sandboxFunction(context) {
+    SandboxFunction.prototype = SB.prototype;
+    return SandboxFunction;
+    function SandboxFunction(...params) {
+        const code = params.pop() || '';
+        const parsed = parse(code);
+        return createFunction(params, parsed.tree, context.ctx.ticks, {
+            ...context,
+            constants: parsed.constants,
+            tree: parsed.tree,
+        }, undefined, 'anonymous');
+    }
+}
+function SAF() { }
+export function sandboxAsyncFunction(context) {
+    SandboxAsyncFunction.prototype = SAF.prototype;
+    return SandboxAsyncFunction;
+    function SandboxAsyncFunction(...params) {
+        const code = params.pop() || '';
+        const parsed = parse(code);
+        return createFunctionAsync(params, parsed.tree, context.ctx.ticks, {
+            ...context,
+            constants: parsed.constants,
+            tree: parsed.tree,
+        }, undefined, 'anonymous');
+    }
+}
+function SE() { }
+export function sandboxedEval(func, context) {
+    sandboxEval.prototype = SE.prototype;
+    return sandboxEval;
+    function sandboxEval(code) {
+        // Parse the code and wrap last statement in return for completion value
+        const parsed = parse(code);
+        const tree = wrapLastStatementInReturn(parsed.tree);
+        // Create and execute function with modified tree
+        return createFunction([], tree, context.ctx.ticks, {
+            ...context,
+            constants: parsed.constants,
+            tree,
+        }, undefined, 'anonymous')();
+    }
+}
+function wrapLastStatementInReturn(tree) {
+    if (tree.length === 0)
+        return tree;
+    const newTree = [...tree];
+    const lastIndex = newTree.length - 1;
+    const lastStmt = newTree[lastIndex];
+    // Only wrap if it's not already a return or throw
+    if (Array.isArray(lastStmt) && lastStmt.length >= 1) {
+        const op = lastStmt[0];
+        // Don't wrap Return (8) or Throw (47) - they already control flow
+        if (op === 8 /* LispType.Return */ || op === 46 /* LispType.Throw */) {
+            return newTree;
+        }
+        // List of statement types that should have undefined completion value
+        // These match JavaScript semantics where declarations and control structures
+        // don't produce a completion value
+        const statementTypes = [
+            3 /* LispType.Let */, // 3
+            4 /* LispType.Const */, // 4
+            34 /* LispType.Var */, // 35
+            37 /* LispType.Function */, // 38
+            13 /* LispType.If */, // 14
+            38 /* LispType.Loop */, // 39
+            39 /* LispType.Try */, // 40
+            40 /* LispType.Switch */, // 41
+            42 /* LispType.Block */, // 43
+            43 /* LispType.Expression */, // 44
+        ];
+        // If the last statement is a declaration or control structure,
+        // don't wrap it (it will naturally return undefined)
+        if (statementTypes.includes(op)) {
+            return newTree;
+        }
+        // For all other types (expressions, operators, etc.),
+        // wrap in return to capture the completion value
+        newTree[lastIndex] = [8 /* LispType.Return */, 0 /* LispType.None */, lastStmt];
+    }
+    return newTree;
+}
+function sST() { }
+export function sandboxedSetTimeout(func, context) {
+    sandboxSetTimeout.prototype = sST.prototype;
+    return sandboxSetTimeout;
+    function sandboxSetTimeout(handler, timeout, ...args) {
+        const sandbox = context.ctx.sandbox;
+        const exec = (...a) => {
+            const h = typeof handler === 'string' ? func(handler) : handler;
+            haltsub.unsubscribe();
+            contsub.unsubscribe();
+            sandbox.setTimeoutHandles.delete(sandBoxhandle);
+            return h(...a);
+        };
+        const sandBoxhandle = ++sandbox.timeoutHandleCounter;
+        let start = Date.now();
+        let handle = setTimeout(exec, timeout, ...args);
+        let elapsed = 0;
+        const haltsub = sandbox.subscribeHalt(() => {
+            elapsed = Date.now() - start + elapsed;
+            clearTimeout(handle);
+        });
+        const contsub = sandbox.subscribeResume(() => {
+            start = Date.now();
+            const remaining = Math.floor((timeout || 0) - elapsed);
+            handle = setTimeout(exec, remaining, ...args);
+            sandbox.setTimeoutHandles.set(sandBoxhandle, {
+                handle,
+                haltsub,
+                contsub,
+            });
+        });
+        sandbox.setTimeoutHandles.set(sandBoxhandle, {
+            handle,
+            haltsub,
+            contsub,
+        });
+        return sandBoxhandle;
+    }
+}
+function sCT() { }
+export function sandboxedClearTimeout(context) {
+    sandboxClearTimeout.prototype = sCT.prototype;
+    return sandboxClearTimeout;
+    function sandboxClearTimeout(handle) {
+        const sandbox = context.ctx.sandbox;
+        const timeoutHandle = sandbox.setTimeoutHandles.get(handle);
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle.handle);
+            timeoutHandle.haltsub.unsubscribe();
+            timeoutHandle.contsub.unsubscribe();
+            sandbox.setTimeoutHandles.delete(handle);
+        }
+    }
+}
+function sCI() { }
+export function sandboxedClearInterval(context) {
+    sandboxClearInterval.prototype = sCI.prototype;
+    return sandboxClearInterval;
+    function sandboxClearInterval(handle) {
+        const sandbox = context.ctx.sandbox;
+        const intervalHandle = sandbox.setIntervalHandles.get(handle);
+        if (intervalHandle) {
+            clearInterval(intervalHandle.handle);
+            intervalHandle.haltsub.unsubscribe();
+            intervalHandle.contsub.unsubscribe();
+            sandbox.setIntervalHandles.delete(handle);
+        }
+    }
+}
+function sSI() { }
+export function sandboxedSetInterval(func, context) {
+    sandboxSetInterval.prototype = sSI.prototype;
+    return sandboxSetInterval;
+    function sandboxSetInterval(handler, timeout, ...args) {
+        const sandbox = context.ctx.sandbox;
+        const h = typeof handler === 'string' ? func(handler) : handler;
+        const exec = (...a) => {
+            start = Date.now();
+            elapsed = 0;
+            return h(...a);
+        };
+        const sandBoxhandle = ++sandbox.timeoutHandleCounter;
+        let start = Date.now();
+        let handle = setInterval(exec, timeout, ...args);
+        let elapsed = 0;
+        const haltsub = sandbox.subscribeHalt(() => {
+            elapsed = Date.now() - start + elapsed;
+            clearInterval(handle);
+        });
+        const contsub = sandbox.subscribeResume(() => {
+            start = Date.now();
+            handle = setTimeout(() => {
+                start = Date.now();
+                elapsed = 0;
+                handle = setInterval(exec, timeout, ...args);
+                exec(...args);
+            }, Math.floor((timeout || 0) - elapsed), ...args);
+            handlObj.handle = handle;
+        });
+        const handlObj = {
+            handle,
+            haltsub,
+            contsub,
+        };
+        sandbox.setIntervalHandles.set(sandBoxhandle, handlObj);
+        return sandBoxhandle;
+    }
+}

package/build/executor.d.ts

@@ -0,0 +1,124 @@
+import { LispItem, Lisp } from './parser.js';
+import { IAuditReport, IExecContext, IScope, LispType, Prop, Scope, Ticks } from './utils.js';
+export type Done<T = any> = (err?: any, res?: T | typeof optional) => void;
+export declare class ExecReturn<T> {
+    auditReport: IAuditReport | undefined;
+    result: T;
+    returned: boolean;
+    breakLoop: boolean;
+    continueLoop: boolean;
+    constructor(auditReport: IAuditReport | undefined, result: T, returned: boolean, breakLoop?: boolean, continueLoop?: boolean);
+}
+export type Unknown = undefined | null | Record<string | number, unknown>;
+export interface IChange {
+    type: string;
+}
+export interface ICreate extends IChange {
+    type: 'create';
+    prop: number | string;
+}
+export interface IReplace extends IChange {
+    type: 'replace';
+}
+export interface IDelete extends IChange {
+    type: 'delete';
+    prop: number | string;
+}
+export interface IReverse extends IChange {
+    type: 'reverse';
+}
+export interface ISort extends IChange {
+    type: 'sort';
+}
+export interface IPush extends IChange {
+    type: 'push';
+    added: unknown[];
+}
+export interface IPop extends IChange {
+    type: 'pop';
+    removed: unknown[];
+}
+export interface IShift extends IChange {
+    type: 'shift';
+    removed: unknown[];
+}
+export interface IUnShift extends IChange {
+    type: 'unshift';
+    added: unknown[];
+}
+export interface ISplice extends IChange {
+    type: 'splice';
+    startIndex: number;
+    deleteCount: number;
+    added: unknown[];
+    removed: unknown[];
+}
+export interface ICopyWithin extends IChange {
+    type: 'copyWithin';
+    startIndex: number;
+    endIndex: number;
+    added: unknown[];
+    removed: unknown[];
+}
+export type Change = ICreate | IReplace | IDelete | IReverse | ISort | IPush | IPop | IUnShift | IShift | ISplice | ICopyWithin;
+declare const optional: {};
+export declare function createFunction(argNames: string[], parsed: Lisp[], ticks: Ticks, context: IExecContext, scope?: Scope, name?: string): (...args: unknown[]) => unknown;
+export declare function createFunctionAsync(argNames: string[], parsed: Lisp[], ticks: Ticks, context: IExecContext, scope?: Scope, name?: string): (...args: unknown[]) => Promise<unknown>;
+export declare function assignCheck(obj: Prop, context: IExecContext, op?: string): void;
+export declare class KeyVal {
+    key: string | SpreadObject;
+    val: unknown;
+    constructor(key: string | SpreadObject, val: unknown);
+}
+export declare class SpreadObject {
+    item: {
+        [key: string]: unknown;
+    };
+    constructor(item: {
+        [key: string]: unknown;
+    });
+}
+export declare class SpreadArray {
+    item: unknown[];
+    constructor(item: unknown[]);
+}
+export declare class If {
+    t: Lisp;
+    f: Lisp;
+    constructor(t: Lisp, f: Lisp);
+}
+type OpCallback<a, b, obj, bobj> = (params: OpsCallbackParams<a, b, obj, bobj>) => void;
+export declare const ops: Map<LispType, OpCallback<any, any, any, any>>;
+export declare function addOps<a = unknown, b = unknown, obj = unknown, bobj = unknown>(type: LispType, cb: OpCallback<a, b, obj, bobj>): void;
+export declare function execMany(ticks: Ticks, exec: Execution, tree: Lisp[], done: Done, scope: Scope, context: IExecContext, inLoopOrSwitch?: string): void;
+type Execution = <T = any>(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, done: Done<T>, inLoopOrSwitch?: string) => void;
+export interface AsyncDoneRet {
+    isInstant: boolean;
+    instant: any;
+    p: Promise<{
+        result: any;
+    }>;
+}
+export declare function asyncDone(callback: (done: Done) => void): AsyncDoneRet;
+export declare function syncDone(callback: (done: Done) => void): {
+    result: any;
+};
+export declare function execAsync<T = any>(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, doneOriginal: Done<T>, inLoopOrSwitch?: string): Promise<void>;
+export declare function execSync<T = any>(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, done: Done<T>, inLoopOrSwitch?: string): void;
+type OpsCallbackParams<a, b, obj, bobj> = {
+    op: LispType;
+    exec: Execution;
+    a: a;
+    b: b;
+    obj: obj;
+    bobj: bobj;
+    ticks: Ticks;
+    tree: LispItem;
+    scope: Scope;
+    context: IExecContext;
+    done: Done;
+    inLoopOrSwitch?: string;
+};
+export declare function executeTree<T>(ticks: Ticks, context: IExecContext, executionTree: Lisp[], scopes?: IScope[], inLoopOrSwitch?: string): ExecReturn<T>;
+export declare function executeTreeAsync<T>(ticks: Ticks, context: IExecContext, executionTree: Lisp[], scopes?: IScope[], inLoopOrSwitch?: string): Promise<ExecReturn<T>>;
+export {};