@nyariv/sandboxjs 0.8.21 → 0.8.23

package/.github/workflows/npm-publish.yml

@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v1
         with:
-          node-version: 12
+          node-version: 18
       - run: npm ci
       - run: npm test
 
@@ -25,7 +25,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v1
         with:
-          node-version: 12
+          node-version: 18
           registry-url: https://registry.npmjs.org/
       - run: npm ci
       - run: npm publish

package/build/Sandbox.d.ts

@@ -1,5 +1,6 @@
-import { IGlobals, replacementCallback, IAuditReport, Change, ExecReturn, executeTree, executeTreeAsync, ops, assignCheck, execMany, execAsync, execSync, asyncDone, Scope, IScope, FunctionScope, LocalScope, syncDone } from "./executor.js";
-import { IExecutionTree, expectTypes, setLispType, LispItem, LispArray, IConstants } from "./parser.js";
+import { IGlobals, IAuditReport, Change, ExecReturn, executeTree, executeTreeAsync, ops, assignCheck, execMany, execAsync, execSync, asyncDone, Scope, IScope, FunctionScope, LocalScope, syncDone } from "./executor.js";
+import { IExecutionTree, expectTypes, setLispType, LispItem, IConstants, Lisp } from "./parser.js";
+type replacementCallback = (obj: any, isStaticAccess: boolean) => any;
 export { expectTypes, setLispType, ops as executionOps, assignCheck, execMany, execAsync, execSync, asyncDone, syncDone, executeTree, executeTreeAsync, FunctionScope, LocalScope, };
 export interface IOptions {
     audit?: boolean;
@@ -39,7 +40,7 @@ export declare class SandboxGlobal {
 export declare class ExecContext implements IExecContext {
     ctx: IContext;
     constants: IConstants;
-    tree: LispArray;
+    tree: Lisp[];
     getSubscriptions: Set<(obj: object, name: string) => void>;
     setSubscriptions: WeakMap<object, Map<string, Set<(modification: Change) => void>>>;
     changeSubscriptions: WeakMap<object, Set<(modification: Change) => void>>;
@@ -47,7 +48,7 @@ export declare class ExecContext implements IExecContext {
     changeSubscriptionsGlobal: WeakMap<object, Set<(modification: Change) => void>>;
     evals: Map<any, any>;
     registerSandboxFunction: (fn: (...args: any[]) => any) => void;
-    constructor(ctx: IContext, constants: IConstants, tree: LispArray, getSubscriptions: Set<(obj: object, name: string) => void>, setSubscriptions: WeakMap<object, Map<string, Set<(modification: Change) => void>>>, changeSubscriptions: WeakMap<object, Set<(modification: Change) => void>>, setSubscriptionsGlobal: WeakMap<object, Map<string, Set<(modification: Change) => void>>>, changeSubscriptionsGlobal: WeakMap<object, Set<(modification: Change) => void>>, evals: Map<any, any>, registerSandboxFunction: (fn: (...args: any[]) => any) => void);
+    constructor(ctx: IContext, constants: IConstants, tree: Lisp[], getSubscriptions: Set<(obj: object, name: string) => void>, setSubscriptions: WeakMap<object, Map<string, Set<(modification: Change) => void>>>, changeSubscriptions: WeakMap<object, Set<(modification: Change) => void>>, setSubscriptionsGlobal: WeakMap<object, Map<string, Set<(modification: Change) => void>>>, changeSubscriptionsGlobal: WeakMap<object, Set<(modification: Change) => void>>, evals: Map<any, any>, registerSandboxFunction: (fn: (...args: any[]) => any) => void);
 }
 export default class Sandbox {
     context: IContext;

package/build/Sandbox.js

@@ -39,7 +39,7 @@ function subscribeSet(obj, name, callback, context) {
     return {
         unsubscribe: () => {
             callbacks.delete(callback);
-            changeCbs === null || changeCbs === void 0 ? void 0 : changeCbs.delete(callback);
+            changeCbs?.delete(callback);
         }
     };
 }
@@ -232,7 +232,7 @@ export default class Sandbox {
         const parsed = parse(code, optimize);
         const exec = (...scopes) => {
             const context = this.createContext(this.context, parsed);
-            return { context, run: async () => (await this.executeTreeAsync(context, [...scopes])).result };
+            return { context, run: () => this.executeTreeAsync(context, [...scopes]).then((ret) => ret.result) };
         };
         return exec;
     }
@@ -249,7 +249,7 @@ export default class Sandbox {
         const parsed = parse(code, optimize, true);
         const exec = (...scopes) => {
             const context = this.createContext(this.context, parsed);
-            return { context, run: async () => (await this.executeTreeAsync(context, [...scopes])).result };
+            return { context, run: () => this.executeTreeAsync(context, [...scopes]).then((ret) => ret.result) };
         };
         return exec;
     }

package/build/executor.d.ts

@@ -1,10 +1,10 @@
-import { LispItem, Lisp, LispArray } from "./parser.js";
+import { LispItem, Lisp, LispType, LispFamily, ExtractLispOp } from "./parser.js";
 import { IExecContext, Ticks } from "./Sandbox.js";
-export declare type SandboxFunction = (code: string, ...args: any[]) => () => any;
-export declare type sandboxedEval = (code: string) => any;
-export declare type sandboxSetTimeout = (handler: TimerHandler, timeout?: any, ...args: any[]) => any;
-export declare type sandboxSetInterval = (handler: TimerHandler, timeout?: any, ...args: any[]) => any;
-export declare type Done = (err?: any, res?: any) => void;
+export type SandboxFunction = (code: string, ...args: unknown[]) => () => unknown;
+export type sandboxedEval = (code: string) => unknown;
+export type sandboxSetTimeout = (handler: TimerHandler, timeout?: number, ...args: unknown[]) => any;
+export type sandboxSetInterval = (handler: TimerHandler, timeout?: number, ...args: unknown[]) => any;
+export type Done = (err?: unknown, res?: unknown) => void;
 export declare class ExecReturn<T> {
     auditReport: IAuditReport;
     result: T;
@@ -14,13 +14,13 @@ export declare class ExecReturn<T> {
     constructor(auditReport: IAuditReport, result: T, returned: boolean, breakLoop?: boolean, continueLoop?: boolean);
 }
 export interface IAuditReport {
-    globalsAccess: Set<any>;
+    globalsAccess: Set<unknown>;
     prototypeAccess: {
         [name: string]: Set<string>;
     };
 }
 export interface IGlobals {
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface IChange {
     type: string;
@@ -72,8 +72,7 @@ export interface ICopyWithin extends IChange {
     added: unknown[];
     removed: unknown[];
 }
-export declare type Change = ICreate | IReplace | IDelete | IReverse | ISort | IPush | IPop | IUnShift | IShift | ISplice | ICopyWithin;
-export declare type replacementCallback = (obj: any, isStaticAccess: boolean) => any;
+export type Change = ICreate | IReplace | IDelete | IReverse | ISort | IPush | IPop | IUnShift | IShift | ISplice | ICopyWithin;
 export declare class Prop {
     context: {
         [key: string]: any;
@@ -85,7 +84,7 @@ export declare class Prop {
     constructor(context: {
         [key: string]: any;
     }, prop: string, isConst?: boolean, isGlobal?: boolean, isVariable?: boolean);
-    get(context: IExecContext): any;
+    get<T = unknown>(context: IExecContext): T;
 }
 declare enum VarType {
     let = "let",
@@ -107,13 +106,13 @@ export declare class Scope {
         [key: string]: true;
     };
     allVars: {
-        [key: string]: any;
+        [key: string]: unknown;
     } & Object;
-    functionThis?: any;
-    constructor(parent: Scope, vars?: {}, functionThis?: any);
+    functionThis?: unknown;
+    constructor(parent: Scope, vars?: {}, functionThis?: unknown);
     get(key: string, functionScope?: boolean): Prop;
-    set(key: string, val: any): Prop;
-    declare(key: string, type?: VarType, value?: any, isGlobal?: boolean): any;
+    set(key: string, val: unknown): Prop;
+    declare(key: string, type?: VarType, value?: unknown, isGlobal?: boolean): Prop;
 }
 export interface IScope {
     [key: string]: any;
@@ -125,16 +124,39 @@ export declare class LocalScope implements IScope {
 export declare class SandboxError extends Error {
 }
 export declare function sandboxFunction(context: IExecContext, ticks?: Ticks): SandboxFunction;
-export declare function createFunction(argNames: string[], parsed: LispItem, ticks: Ticks, context: IExecContext, scope?: Scope, name?: string): any;
-export declare function createFunctionAsync(argNames: string[], parsed: LispItem, ticks: Ticks, context: IExecContext, scope?: Scope, name?: string): any;
+export declare function createFunction(argNames: string[], parsed: Lisp[], ticks: Ticks, context: IExecContext, scope?: Scope, name?: string): any;
+export declare function createFunctionAsync(argNames: string[], parsed: Lisp[], ticks: Ticks, context: IExecContext, scope?: Scope, name?: string): any;
 export declare function sandboxedEval(func: SandboxFunction): sandboxedEval;
 export declare function sandboxedSetTimeout(func: SandboxFunction): sandboxSetTimeout;
 export declare function sandboxedSetInterval(func: SandboxFunction): sandboxSetInterval;
 export declare function assignCheck(obj: Prop, context: IExecContext, op?: string): void;
-declare type OpCallback = (exec: Execution, done: Done, ticks: Ticks, a: LispItem | string[], b: LispItem | Lisp[], obj: Prop | any | undefined, context: IExecContext, scope: Scope, bobj?: Prop | any | undefined, inLoopOrSwitch?: string) => void;
-export declare let ops: Map<string, OpCallback>;
-export declare function execMany(ticks: Ticks, exec: Execution, tree: LispArray, done: Done, scope: Scope, context: IExecContext, inLoopOrSwitch?: string): void;
-declare type Execution = (ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, done: Done, inLoopOrSwitch?: 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 = (exec: Execution, done: Done, ticks: Ticks, a: any, b: any, obj: any, context: IExecContext, scope: Scope, bobj?: any, inLoopOrSwitch?: string) => void;
+export declare const ops: Map<LispType, OpCallback>;
+export declare function addOps<Type extends LispFamily>(type: ExtractLispOp<Type>, cb: OpCallback): void;
+export declare function execMany(ticks: Ticks, exec: Execution, tree: Lisp[], done: Done, scope: Scope, context: IExecContext, inLoopOrSwitch?: string): void;
+type Execution = (ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, done: Done, inLoopOrSwitch?: string) => void;
 export interface AsyncDoneRet {
     isInstant: boolean;
     instant: any;
@@ -148,6 +170,6 @@ export declare function syncDone(callback: (done: Done) => void): {
 };
 export declare function execAsync(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, doneOriginal: Done, inLoopOrSwitch?: string): Promise<void>;
 export declare function execSync(ticks: Ticks, tree: LispItem, scope: Scope, context: IExecContext, done: Done, inLoopOrSwitch?: string): void;
-export declare function executeTree<T>(ticks: Ticks, context: IExecContext, executionTree: LispItem, scopes?: (IScope)[], inLoopOrSwitch?: string): ExecReturn<T>;
-export declare function executeTreeAsync<T>(ticks: Ticks, context: IExecContext, executionTree: LispItem, scopes?: (IScope)[], inLoopOrSwitch?: string): Promise<ExecReturn<T>>;
+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 {};