@zvenigora/ng-eval-core 0.1.104 → 0.1.106

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (29) hide show
  1. package/esm2022/lib/actual/services/base-eval.mjs +32 -1
  2. package/esm2022/lib/actual/services/compiler.service.mjs +66 -40
  3. package/esm2022/lib/actual/services/discovery.service.mjs +4 -23
  4. package/esm2022/lib/actual/services/eval.service.mjs +65 -30
  5. package/esm2022/lib/actual/services/parser.service.mjs +19 -9
  6. package/esm2022/lib/internal/classes/eval/eval-context.mjs +21 -3
  7. package/esm2022/lib/internal/classes/eval/eval-result.mjs +19 -3
  8. package/esm2022/lib/internal/classes/eval/eval-scope.mjs +83 -0
  9. package/esm2022/lib/internal/classes/eval/eval-state.mjs +1 -1
  10. package/esm2022/lib/internal/classes/eval/eval-trace.mjs +22 -0
  11. package/esm2022/lib/internal/classes/eval/parser-options.mjs +8 -0
  12. package/esm2022/lib/internal/classes/eval/public-api.mjs +4 -1
  13. package/esm2022/lib/internal/visitors/member-expression.mjs +7 -1
  14. package/esm2022/lib/internal/visitors/visitor-result.mjs +3 -9
  15. package/fesm2022/zvenigora-ng-eval-core.mjs +1026 -800
  16. package/fesm2022/zvenigora-ng-eval-core.mjs.map +1 -1
  17. package/lib/actual/services/base-eval.d.ts +21 -2
  18. package/lib/actual/services/compiler.service.d.ts +28 -16
  19. package/lib/actual/services/discovery.service.d.ts +1 -7
  20. package/lib/actual/services/eval.service.d.ts +22 -10
  21. package/lib/actual/services/parser.service.d.ts +11 -2
  22. package/lib/internal/classes/eval/eval-context.d.ts +9 -1
  23. package/lib/internal/classes/eval/eval-result.d.ts +16 -3
  24. package/lib/internal/classes/eval/eval-scope.d.ts +51 -0
  25. package/lib/internal/classes/eval/eval-state.d.ts +4 -4
  26. package/lib/internal/classes/eval/eval-trace.d.ts +20 -0
  27. package/lib/internal/classes/eval/parser-options.d.ts +2 -0
  28. package/lib/internal/classes/eval/public-api.d.ts +3 -0
  29. package/package.json +1 -1
@@ -1,7 +1,11 @@
1
+ import { EvalState } from "../../internal/classes/eval";
1
2
  /**
2
3
  * Base class for evaluation.
3
4
  */
4
5
  export class BaseEval {
6
+ constructor(parserService) {
7
+ this.parserService = parserService;
8
+ }
5
9
  /**
6
10
  * Gets the parser options.
7
11
  */
@@ -15,5 +19,32 @@ export class BaseEval {
15
19
  set parserOptions(value) {
16
20
  this._parserOptions = value;
17
21
  }
22
+ /**
23
+ * Parses the given expression into an abstract syntax tree (AST).
24
+ * @param expression - The expression to parse.
25
+ * @returns The parsed AST.
26
+ */
27
+ parse(expression) {
28
+ if (!expression) {
29
+ return undefined;
30
+ }
31
+ else if (typeof expression === 'string') {
32
+ const ast = this.parserService.parse(expression, this.parserOptions);
33
+ return ast;
34
+ }
35
+ else {
36
+ return expression;
37
+ }
38
+ }
39
+ /**
40
+ * Creates an instance of EvalState.
41
+ * @param context - The evaluation context or context object.
42
+ * @param options - The evaluation options.
43
+ * @returns The created EvalState instance.
44
+ */
45
+ createState(context, options) {
46
+ const state = EvalState.fromContext(context, options);
47
+ return state;
48
+ }
18
49
  }
19
- //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1ldmFsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbW9kdWxlcy9ldmFsLWNvcmUvc3JjL2xpYi9hY3R1YWwvc2VydmljZXMvYmFzZS1ldmFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gsTUFBTSxPQUFnQixRQUFRO0lBRzVCOztPQUVHO0lBQ0gsSUFBSSxhQUFhO1FBQ2YsT0FBTyxJQUFJLENBQUMsY0FBYyxDQUFDO0lBQzdCLENBQUM7SUFFRDs7O09BR0c7SUFDSCxJQUFJLGFBQWEsQ0FBQyxLQUFvQjtRQUNwQyxJQUFJLENBQUMsY0FBYyxHQUFHLEtBQUssQ0FBQztJQUM5QixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQYXJzZXJPcHRpb25zIH0gZnJvbSBcIi4uLy4uL2ludGVybmFsL2ludGVyZmFjZXNcIjtcclxuXHJcbi8qKlxyXG4gKiBCYXNlIGNsYXNzIGZvciBldmFsdWF0aW9uLlxyXG4gKi9cclxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEJhc2VFdmFsIHtcclxuICBwcml2YXRlIF9wYXJzZXJPcHRpb25zITogUGFyc2VyT3B0aW9ucztcclxuXHJcbiAgLyoqXHJcbiAgICogR2V0cyB0aGUgcGFyc2VyIG9wdGlvbnMuXHJcbiAgICovXHJcbiAgZ2V0IHBhcnNlck9wdGlvbnMoKTogUGFyc2VyT3B0aW9ucyB7XHJcbiAgICByZXR1cm4gdGhpcy5fcGFyc2VyT3B0aW9ucztcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIFNldHMgdGhlIHBhcnNlciBvcHRpb25zLlxyXG4gICAqIEBwYXJhbSB2YWx1ZSBUaGUgcGFyc2VyIG9wdGlvbnMgdG8gc2V0LlxyXG4gICAqL1xyXG4gIHNldCBwYXJzZXJPcHRpb25zKHZhbHVlOiBQYXJzZXJPcHRpb25zKSB7XHJcbiAgICB0aGlzLl9wYXJzZXJPcHRpb25zID0gdmFsdWU7XHJcbiAgfVxyXG59XHJcbiJdfQ==
50
+ //# sourceMappingURL=data:application/json;base64,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
@@ -2,8 +2,7 @@ import { Injectable } from '@angular/core';
2
2
  import { BaseEval } from './base-eval';
3
3
  import { ParserService } from './parser.service';
4
4
  import { EvalService } from './eval.service';
5
- import { EvalState } from '../../internal/classes/eval';
6
- import { defaultOptions } from 'acorn';
5
+ import { defaultParserOptions } from '../../internal/classes/eval';
7
6
  import { call as _call, callAsync as _callAsync, compile as _compile, compileAsync as _compileAsync } from '../../internal/functions';
8
7
  import * as i0 from "@angular/core";
9
8
  import * as i1 from "./parser.service";
@@ -14,32 +13,10 @@ import * as i2 from "./eval.service";
14
13
  */
15
14
  export class CompilerService extends BaseEval {
16
15
  constructor(parserService, evalService) {
17
- super();
16
+ super(parserService);
18
17
  this.parserService = parserService;
19
18
  this.evalService = evalService;
20
- this.parserOptions = {
21
- ...defaultOptions,
22
- ecmaVersion: 2020,
23
- extractExpressions: false,
24
- cacheSize: 100
25
- };
26
- }
27
- /**
28
- * Parses the given expression into an abstract syntax tree (AST).
29
- * @param expression - The expression to parse.
30
- * @returns The parsed AST.
31
- */
32
- parse(expression) {
33
- if (!expression) {
34
- return undefined;
35
- }
36
- else if (typeof expression === 'string') {
37
- const ast = this.parserService.parse(expression, this.parserOptions);
38
- return ast;
39
- }
40
- else {
41
- return expression;
42
- }
19
+ this.parserOptions = defaultParserOptions;
43
20
  }
44
21
  /**
45
22
  * Compiles the given expression into a state callback function.
@@ -68,10 +45,10 @@ export class CompilerService extends BaseEval {
68
45
  * @returns The result of the evaluation.
69
46
  * @throws Error if there is an error during the evaluation.
70
47
  */
71
- call(fn, context, options) {
48
+ simpleCall(fn, context, options) {
72
49
  if (fn) {
73
50
  try {
74
- const state = EvalState.fromContext(context, options);
51
+ const state = this.createState(context, options);
75
52
  const value = _call(fn, state);
76
53
  return value;
77
54
  }
@@ -87,26 +64,26 @@ export class CompilerService extends BaseEval {
87
64
  return undefined;
88
65
  }
89
66
  /**
90
- * Calls the given asynchronous state callback function with the specified context and options.
91
- * @param fn - The asynchronous state callback function to call.
92
- * @param context - The evaluation context or context object.
93
- * @param options - The evaluation options.
94
- * @returns A promise that resolves to the result of the evaluation.
95
- * @throws Error if there is an error during the evaluation.
67
+ * Calls the provided function with the given state.
68
+ *
69
+ * @param fn - The function to be called.
70
+ * @param state - The state to be passed to the function.
71
+ * @returns The value returned by the function.
72
+ * @throws If an error occurs during the function call.
96
73
  */
97
- async callAsync(fn, context, options) {
74
+ call(fn, state) {
98
75
  if (fn) {
99
76
  try {
100
- const state = EvalState.fromContext(context, options);
101
- const promise = _callAsync(fn, state);
102
- const value = await promise;
77
+ const value = _call(fn, state);
103
78
  return value;
104
79
  }
105
80
  catch (error) {
106
81
  if (error instanceof Error) {
107
82
  throw new Error(error.message);
108
83
  }
109
- throw new Error('error in callAsync');
84
+ else {
85
+ throw new Error('call');
86
+ }
110
87
  }
111
88
  }
112
89
  return undefined;
@@ -130,6 +107,55 @@ export class CompilerService extends BaseEval {
130
107
  throw new Error('error in compileAsync');
131
108
  }
132
109
  }
110
+ /**
111
+ * Calls the given asynchronous state callback function with the specified context and options.
112
+ * @param fn - The asynchronous state callback function to call.
113
+ * @param context - The evaluation context or context object.
114
+ * @param options - The evaluation options.
115
+ * @returns A promise that resolves to the result of the evaluation.
116
+ * @throws Error if there is an error during the evaluation.
117
+ */
118
+ async simpleCallAsync(fn, context, options) {
119
+ if (fn) {
120
+ try {
121
+ const state = this.createState(context, options);
122
+ const promise = _callAsync(fn, state);
123
+ const value = await promise;
124
+ return value;
125
+ }
126
+ catch (error) {
127
+ if (error instanceof Error) {
128
+ throw new Error(error.message);
129
+ }
130
+ throw new Error('error in callAsync');
131
+ }
132
+ }
133
+ return undefined;
134
+ }
135
+ /**
136
+ * Calls the provided asynchronous function with the given state.
137
+ *
138
+ * @param fn - The asynchronous function to call.
139
+ * @param state - The state to pass to the function.
140
+ * @returns A promise that resolves to the value returned by the function.
141
+ * @throws If an error occurs during the function call.
142
+ */
143
+ async callAsync(fn, state) {
144
+ if (fn) {
145
+ try {
146
+ const promise = _callAsync(fn, state);
147
+ const value = await promise;
148
+ return value;
149
+ }
150
+ catch (error) {
151
+ if (error instanceof Error) {
152
+ throw new Error(error.message);
153
+ }
154
+ throw new Error('error in callAsync');
155
+ }
156
+ }
157
+ return undefined;
158
+ }
133
159
  static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: CompilerService, deps: [{ token: i1.ParserService }, { token: i2.EvalService }], target: i0.ɵɵFactoryTarget.Injectable }); }
134
160
  static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: CompilerService, providedIn: 'root' }); }
135
161
  }
@@ -139,4 +165,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImpor
139
165
  providedIn: 'root'
140
166
  }]
141
167
  }], ctorParameters: () => [{ type: i1.ParserService }, { type: i2.EvalService }] });
142
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compiler.service.js","sourceRoot":"","sources":["../../../../../../../modules/eval-core/src/lib/actual/services/compiler.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { BaseEval } from './base-eval';\r\nimport { ParserService } from './parser.service';\r\nimport { EvalService } from './eval.service';\r\nimport { EvalContext, EvalOptions, EvalState } from '../../internal/classes/eval';\r\nimport { Context } from '../../internal/classes/common';\r\nimport { AnyNode, defaultOptions } from 'acorn';\r\nimport { call as _call, callAsync as _callAsync,\r\n  compile as _compile, compileAsync as _compileAsync,\r\n  stateCallback, stateCallbackAsync } from '../../internal/functions';\r\n\r\n/**\r\n * CompilerService class that extends BaseEval.\r\n * Provides methods for compiling and evaluating expressions.\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CompilerService extends BaseEval {\r\n\r\n  constructor(\r\n    public parserService: ParserService,\r\n    public evalService: EvalService\r\n  ) {\r\n    super();\r\n    this.parserOptions = {\r\n      ...defaultOptions,\r\n      ecmaVersion: 2020,\r\n      extractExpressions: false,\r\n      cacheSize: 100\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Parses the given expression into an abstract syntax tree (AST).\r\n   * @param expression - The expression to parse.\r\n   * @returns The parsed AST.\r\n   */\r\n  private parse(expression: string | AnyNode | undefined): AnyNode | undefined {\r\n    if (!expression) {\r\n      return undefined;\r\n    } else if (typeof expression === 'string') {\r\n      const ast = this.parserService.parse(expression, this.parserOptions);\r\n      return ast;\r\n    } else {\r\n      return expression as AnyNode;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Compiles the given expression into a state callback function.\r\n   * @param expression - The expression to compile.\r\n   * @returns The compiled state callback function.\r\n   * @throws Error if there is an error during compilation.\r\n   */\r\n  compile(expression: string | AnyNode | undefined): stateCallback | undefined {\r\n    try {\r\n      const ast = this.parse(expression);\r\n      const fn = _compile(ast);\r\n      return fn;\r\n    } catch (error) {\r\n      if (error instanceof Error) {\r\n        throw new Error(error.message);\r\n      }\r\n      throw new Error('error in compile');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Calls the given state callback function with the specified context and options.\r\n   * @param fn - The state callback function to call.\r\n   * @param context - The evaluation context or context object.\r\n   * @param options - The evaluation options.\r\n   * @returns The result of the evaluation.\r\n   * @throws Error if there is an error during the evaluation.\r\n   */\r\n  call(fn: stateCallback | undefined, context?: EvalContext | Context, options?: EvalOptions) {\r\n    if (fn) {\r\n      try {\r\n        const state = EvalState.fromContext(context, options);\r\n        const value = _call(fn, state);\r\n        return value;\r\n      } catch (error) {\r\n        if (error instanceof Error) {\r\n          throw new Error(error.message);\r\n        } else {\r\n          throw new Error('call');\r\n        }\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  /**\r\n   * Calls the given asynchronous state callback function with the specified context and options.\r\n   * @param fn - The asynchronous state callback function to call.\r\n   * @param context - The evaluation context or context object.\r\n   * @param options - The evaluation options.\r\n   * @returns A promise that resolves to the result of the evaluation.\r\n   * @throws Error if there is an error during the evaluation.\r\n   */\r\n  async callAsync(fn: stateCallbackAsync | undefined, context?: EvalContext | Context, options?: EvalOptions) {\r\n    if (fn) {\r\n      try {\r\n        const state = EvalState.fromContext(context, options);\r\n        const promise = _callAsync(fn, state);\r\n        const value = await promise;\r\n        return value;\r\n      } catch (error) {\r\n        if (error instanceof Error) {\r\n          throw new Error(error.message);\r\n        }\r\n        throw new Error('error in callAsync');\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  /**\r\n   * Compiles the given expression into an asynchronous state callback function.\r\n   * @param expression - The expression to compile.\r\n   * @returns The compiled asynchronous state callback function.\r\n   * @throws Error if there is an error during compilation.\r\n   */\r\n  compileAsync(expression: string | AnyNode | undefined): stateCallbackAsync | undefined {\r\n    try {\r\n      const ast = this.parse(expression);\r\n      const fn = _compileAsync(ast);\r\n      return fn;\r\n    } catch (error) {\r\n      if (error instanceof Error) {\r\n        throw new Error(error.message);\r\n      }\r\n      throw new Error('error in compileAsync');\r\n    }\r\n  }\r\n\r\n}\r\n"]}
168
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compiler.service.js","sourceRoot":"","sources":["../../../../../../../modules/eval-core/src/lib/actual/services/compiler.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { BaseEval } from './base-eval';\r\nimport { ParserService } from './parser.service';\r\nimport { EvalService } from './eval.service';\r\nimport { EvalContext, EvalOptions, EvalState, defaultParserOptions } from '../../internal/classes/eval';\r\nimport { Context } from '../../internal/classes/common';\r\nimport { AnyNode } from 'acorn';\r\nimport { call as _call, callAsync as _callAsync,\r\n  compile as _compile, compileAsync as _compileAsync,\r\n  stateCallback, stateCallbackAsync } from '../../internal/functions';\r\n\r\n/**\r\n * CompilerService class that extends BaseEval.\r\n * Provides methods for compiling and evaluating expressions.\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class CompilerService extends BaseEval {\r\n\r\n  constructor(\r\n    protected override parserService: ParserService,\r\n    protected evalService: EvalService\r\n  ) {\r\n    super(parserService);\r\n    this.parserOptions = defaultParserOptions;\r\n  }\r\n\r\n  /**\r\n   * Compiles the given expression into a state callback function.\r\n   * @param expression - The expression to compile.\r\n   * @returns The compiled state callback function.\r\n   * @throws Error if there is an error during compilation.\r\n   */\r\n  compile(expression: string | AnyNode | undefined): stateCallback | undefined {\r\n    try {\r\n      const ast = this.parse(expression);\r\n      const fn = _compile(ast);\r\n      return fn;\r\n    } catch (error) {\r\n      if (error instanceof Error) {\r\n        throw new Error(error.message);\r\n      }\r\n      throw new Error('error in compile');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Calls the given state callback function with the specified context and options.\r\n   * @param fn - The state callback function to call.\r\n   * @param context - The evaluation context or context object.\r\n   * @param options - The evaluation options.\r\n   * @returns The result of the evaluation.\r\n   * @throws Error if there is an error during the evaluation.\r\n   */\r\n  simpleCall(fn: stateCallback | undefined,\r\n             context?: EvalContext | Context,\r\n             options?: EvalOptions) {\r\n    if (fn) {\r\n      try {\r\n        const state = this.createState(context, options);\r\n        const value = _call(fn, state);\r\n        return value;\r\n      } catch (error) {\r\n        if (error instanceof Error) {\r\n          throw new Error(error.message);\r\n        } else {\r\n          throw new Error('call');\r\n        }\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n\r\n  /**\r\n   * Calls the provided function with the given state.\r\n   *\r\n   * @param fn - The function to be called.\r\n   * @param state - The state to be passed to the function.\r\n   * @returns The value returned by the function.\r\n   * @throws If an error occurs during the function call.\r\n   */\r\n  call(fn: stateCallback | undefined,\r\n       state: EvalState) {\r\n    if (fn) {\r\n      try {\r\n        const value = _call(fn, state);\r\n        return value;\r\n      } catch (error) {\r\n        if (error instanceof Error) {\r\n          throw new Error(error.message);\r\n        } else {\r\n          throw new Error('call');\r\n        }\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  /**\r\n   * Compiles the given expression into an asynchronous state callback function.\r\n   * @param expression - The expression to compile.\r\n   * @returns The compiled asynchronous state callback function.\r\n   * @throws Error if there is an error during compilation.\r\n   */\r\n  compileAsync(expression: string | AnyNode | undefined): stateCallbackAsync | undefined {\r\n    try {\r\n      const ast = this.parse(expression);\r\n      const fn = _compileAsync(ast);\r\n      return fn;\r\n    } catch (error) {\r\n      if (error instanceof Error) {\r\n        throw new Error(error.message);\r\n      }\r\n      throw new Error('error in compileAsync');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Calls the given asynchronous state callback function with the specified context and options.\r\n   * @param fn - The asynchronous state callback function to call.\r\n   * @param context - The evaluation context or context object.\r\n   * @param options - The evaluation options.\r\n   * @returns A promise that resolves to the result of the evaluation.\r\n   * @throws Error if there is an error during the evaluation.\r\n   */\r\n  async simpleCallAsync(fn: stateCallbackAsync | undefined,\r\n                        context?: EvalContext | Context,\r\n                        options?: EvalOptions) {\r\n    if (fn) {\r\n      try {\r\n        const state = this.createState(context, options);\r\n        const promise = _callAsync(fn, state);\r\n        const value = await promise;\r\n        return value;\r\n      } catch (error) {\r\n        if (error instanceof Error) {\r\n          throw new Error(error.message);\r\n        }\r\n        throw new Error('error in callAsync');\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n\r\n  /**\r\n   * Calls the provided asynchronous function with the given state.\r\n   *\r\n   * @param fn - The asynchronous function to call.\r\n   * @param state - The state to pass to the function.\r\n   * @returns A promise that resolves to the value returned by the function.\r\n   * @throws If an error occurs during the function call.\r\n   */\r\n  async callAsync(fn: stateCallbackAsync | undefined,\r\n                  state: EvalState) {\r\n    if (fn) {\r\n      try {\r\n        const promise = _callAsync(fn, state);\r\n        const value = await promise;\r\n        return value;\r\n      } catch (error) {\r\n        if (error instanceof Error) {\r\n          throw new Error(error.message);\r\n        }\r\n        throw new Error('error in callAsync');\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n}\r\n"]}
@@ -1,8 +1,8 @@
1
1
  import { Injectable } from '@angular/core';
2
2
  import { BaseEval } from './base-eval';
3
3
  import { ParserService } from './parser.service';
4
- import { defaultOptions } from 'acorn';
5
4
  import { extract } from '../../internal/functions';
5
+ import { defaultParserOptions } from '../../internal/classes/eval';
6
6
  import * as i0 from "@angular/core";
7
7
  import * as i1 from "./parser.service";
8
8
  /**
@@ -14,12 +14,10 @@ export class DiscoveryService extends BaseEval {
14
14
  * @param parserService The parser service to be used.
15
15
  */
16
16
  constructor(parserService) {
17
- super();
17
+ super(parserService);
18
18
  this.parserService = parserService;
19
19
  this.parserOptions = {
20
- ...defaultOptions,
21
- ecmaVersion: 2020,
22
- extractExpressions: false,
20
+ ...defaultParserOptions,
23
21
  cacheSize: undefined
24
22
  };
25
23
  }
@@ -46,23 +44,6 @@ export class DiscoveryService extends BaseEval {
46
44
  }
47
45
  }
48
46
  }
49
- /**
50
- * Parses the given expression into an abstract syntax tree (AST).
51
- * @param expression The expression to parse.
52
- * @returns The AST representing the expression.
53
- */
54
- parse(expression) {
55
- if (!expression) {
56
- return undefined;
57
- }
58
- else if (typeof expression === 'string') {
59
- const ast = this.parserService.parse(expression, this.parserOptions);
60
- return ast;
61
- }
62
- else {
63
- return expression;
64
- }
65
- }
66
47
  static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DiscoveryService, deps: [{ token: i1.ParserService }], target: i0.ɵɵFactoryTarget.Injectable }); }
67
48
  static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: DiscoveryService, providedIn: 'root' }); }
68
49
  }
@@ -72,4 +53,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImpor
72
53
  providedIn: 'root'
73
54
  }]
74
55
  }], ctorParameters: () => [{ type: i1.ParserService }] });
75
- //# sourceMappingURL=data:application/json;base64,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
56
+ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzY292ZXJ5LnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL2V2YWwtY29yZS9zcmMvbGliL2FjdHVhbC9zZXJ2aWNlcy9kaXNjb3Zlcnkuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDdkMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBR2pELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQzs7O0FBRW5FOztHQUVHO0FBSUgsTUFBTSxPQUFPLGdCQUFpQixTQUFRLFFBQVE7SUFFNUM7OztPQUdHO0lBQ0gsWUFDcUIsYUFBNEI7UUFFL0MsS0FBSyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBRkYsa0JBQWEsR0FBYixhQUFhLENBQWU7UUFJL0MsSUFBSSxDQUFDLGFBQWEsR0FBRztZQUNuQixHQUFHLG9CQUFvQjtZQUN2QixTQUFTLEVBQUUsU0FBUztTQUNyQixDQUFDO0lBQ0osQ0FBQztJQUVEOzs7Ozs7O09BT0c7SUFDSCxPQUFPLENBQUMsVUFBd0MsRUFDOUMsVUFBd0I7UUFDeEIsSUFBSTtZQUNGLE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDbkMsTUFBTSxLQUFLLEdBQUcsT0FBTyxDQUFDLEdBQUcsRUFBRSxVQUFVLENBQUMsQ0FBQztZQUN2QyxPQUFPLEtBQUssQ0FBQztTQUNkO1FBQUMsT0FBTyxLQUFLLEVBQUU7WUFDZCxJQUFJLEtBQUssWUFBWSxLQUFLLEVBQUU7Z0JBQzFCLE1BQU0sSUFBSSxLQUFLLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO2FBQ2hDO2lCQUFNO2dCQUNMLE1BQU0sS0FBSyxDQUFDO2FBQ2I7U0FDRjtJQUNILENBQUM7OEdBdENVLGdCQUFnQjtrSEFBaEIsZ0JBQWdCLGNBRmYsTUFBTTs7MkZBRVAsZ0JBQWdCO2tCQUg1QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQmFzZUV2YWwgfSBmcm9tICcuL2Jhc2UtZXZhbCc7XHJcbmltcG9ydCB7IFBhcnNlclNlcnZpY2UgfSBmcm9tICcuL3BhcnNlci5zZXJ2aWNlJztcclxuaW1wb3J0IHsgQW55Tm9kZSB9IGZyb20gJ2Fjb3JuJztcclxuaW1wb3J0IHsgQW55Tm9kZVR5cGVzIH0gZnJvbSAnLi4vLi4vaW50ZXJuYWwvaW50ZXJmYWNlcyc7XHJcbmltcG9ydCB7IGV4dHJhY3QgfSBmcm9tICcuLi8uLi9pbnRlcm5hbC9mdW5jdGlvbnMnO1xyXG5pbXBvcnQgeyBkZWZhdWx0UGFyc2VyT3B0aW9ucyB9IGZyb20gJy4uLy4uL2ludGVybmFsL2NsYXNzZXMvZXZhbCc7XHJcblxyXG4vKipcclxuICogU2VydmljZSByZXNwb25zaWJsZSBmb3IgZGlzY292ZXJpbmcgbm9kZXMgaW4gYW4gYWJzdHJhY3Qgc3ludGF4IHRyZWUgKEFTVCkuXHJcbiAqL1xyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBEaXNjb3ZlcnlTZXJ2aWNlIGV4dGVuZHMgQmFzZUV2YWwge1xyXG5cclxuICAvKipcclxuICAgKiBDcmVhdGVzIGEgbmV3IGluc3RhbmNlIG9mIHRoZSBEaXNjb3ZlcnlTZXJ2aWNlIGNsYXNzLlxyXG4gICAqIEBwYXJhbSBwYXJzZXJTZXJ2aWNlIFRoZSBwYXJzZXIgc2VydmljZSB0byBiZSB1c2VkLlxyXG4gICAqL1xyXG4gIGNvbnN0cnVjdG9yKFxyXG4gICAgcHJvdGVjdGVkIG92ZXJyaWRlIHBhcnNlclNlcnZpY2U6IFBhcnNlclNlcnZpY2VcclxuICApIHtcclxuICAgIHN1cGVyKHBhcnNlclNlcnZpY2UpO1xyXG5cclxuICAgIHRoaXMucGFyc2VyT3B0aW9ucyA9IHtcclxuICAgICAgLi4uZGVmYXVsdFBhcnNlck9wdGlvbnMsXHJcbiAgICAgIGNhY2hlU2l6ZTogdW5kZWZpbmVkXHJcbiAgICB9O1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogRmluZHMgYWxsIG5vZGVzIGluIHRoZSBBU1QgdGhhdCBtYXRjaCB0aGUgZ2l2ZW4gZXhwcmVzc2lvbiBhbmQgc2VhcmNoIHR5cGUuXHJcbiAgICogQHBhcmFtIGV4cHJlc3Npb24gVGhlIGV4cHJlc3Npb24gdG8gc2VhcmNoIGZvci4gQ2FuIGJlIGEgc3RyaW5nIG9yIGFuIEFTVCBub2RlLlxyXG4gICAqIEBwYXJhbSBzZWFyY2hUeXBlIFRoZSB0eXBlIG9mIG5vZGVzIHRvIHNlYXJjaCBmb3IuXHJcbiAgICogQHBhcmFtIG9wdGlvbnMgT3B0aW9uYWwgcGFyc2VyIG9wdGlvbnMuXHJcbiAgICogQHJldHVybnMgQW4gYXJyYXkgb2Ygbm9kZXMgdGhhdCBtYXRjaCB0aGUgc2VhcmNoIGNyaXRlcmlhLCBvciB1bmRlZmluZWQgaWYgbm8gbm9kZXMgYXJlIGZvdW5kLlxyXG4gICAqIEB0aHJvd3MgSWYgYW4gZXJyb3Igb2NjdXJzIGR1cmluZyB0aGUgc2VhcmNoIHByb2Nlc3MuXHJcbiAgICovXHJcbiAgZXh0cmFjdChleHByZXNzaW9uOiBzdHJpbmcgfCBBbnlOb2RlIHwgdW5kZWZpbmVkLFxyXG4gICAgc2VhcmNoVHlwZTogQW55Tm9kZVR5cGVzKTogQW55Tm9kZVtdIHwgdW5kZWZpbmVkIHtcclxuICAgIHRyeSB7XHJcbiAgICAgIGNvbnN0IGFzdCA9IHRoaXMucGFyc2UoZXhwcmVzc2lvbik7XHJcbiAgICAgIGNvbnN0IHZhbHVlID0gZXh0cmFjdChhc3QsIHNlYXJjaFR5cGUpO1xyXG4gICAgICByZXR1cm4gdmFsdWU7XHJcbiAgICB9IGNhdGNoIChlcnJvcikge1xyXG4gICAgICBpZiAoZXJyb3IgaW5zdGFuY2VvZiBFcnJvcikge1xyXG4gICAgICAgIHRocm93IG5ldyBFcnJvcihlcnJvci5tZXNzYWdlKTtcclxuICAgICAgfSBlbHNlIHtcclxuICAgICAgICB0aHJvdyBlcnJvcjtcclxuICAgICAgfVxyXG4gICAgfVxyXG4gIH1cclxuXHJcbn1cclxuIl19
@@ -1,8 +1,7 @@
1
1
  import { Injectable } from '@angular/core';
2
2
  import { BaseEval } from './base-eval';
3
3
  import { ParserService } from './parser.service';
4
- import { defaultOptions } from 'acorn';
5
- import { EvalState } from '../../internal/classes/eval';
4
+ import { defaultParserOptions } from '../../internal/classes/eval';
6
5
  import { evaluate, evaluateAsync } from '../../internal/functions';
7
6
  import * as i0 from "@angular/core";
8
7
  import * as i1 from "./parser.service";
@@ -15,43 +14,50 @@ export class EvalService extends BaseEval {
15
14
  * @param parserService The parser service used for parsing expressions.
16
15
  */
17
16
  constructor(parserService) {
18
- super();
17
+ super(parserService);
19
18
  this.parserService = parserService;
20
- this.parserOptions = {
21
- ...defaultOptions,
22
- ecmaVersion: 2020,
23
- extractExpressions: false,
24
- cacheSize: 100
25
- };
19
+ this.parserOptions = defaultParserOptions;
26
20
  }
27
21
  /**
28
- * Parses the given expression into an abstract syntax tree (AST).
29
- * @param expression The expression to parse.
30
- * @returns The AST representing the expression.
22
+ * Evaluates the given expression.
23
+ * @param expression The expression to evaluate.
24
+ * @param context The evaluation context.
25
+ * @param options The evaluation options.
26
+ * @returns The result of the evaluation.
31
27
  */
32
- parse(expression) {
33
- if (!expression) {
34
- return undefined;
35
- }
36
- else if (typeof expression === 'string') {
37
- const ast = this.parserService.parse(expression, this.parserOptions);
38
- return ast;
28
+ simpleEval(expression, context, options) {
29
+ try {
30
+ const ast = this.parse(expression);
31
+ const state = this.createState(context, options);
32
+ if (state?.result && typeof expression === 'string') {
33
+ state.result.expression = expression;
34
+ }
35
+ const value = evaluate(ast, state);
36
+ return value;
39
37
  }
40
- else {
41
- return expression;
38
+ catch (error) {
39
+ if (error instanceof Error) {
40
+ throw new Error(error.message);
41
+ }
42
+ else {
43
+ throw error;
44
+ }
42
45
  }
43
46
  }
44
47
  /**
45
- * Evaluates the given expression.
46
- * @param expression The expression to evaluate.
47
- * @param context The evaluation context.
48
- * @param options The evaluation options.
48
+ * Evaluates an expression using the provided state.
49
+ *
50
+ * @param expression - The expression to evaluate.
51
+ * @param state - The state object containing variables and functions used in the evaluation.
49
52
  * @returns The result of the evaluation.
53
+ * @throws If an error occurs during evaluation.
50
54
  */
51
- eval(expression, context, options) {
55
+ eval(expression, state) {
52
56
  try {
53
57
  const ast = this.parse(expression);
54
- const state = EvalState.fromContext(context, options);
58
+ if (state?.result && typeof expression === 'string') {
59
+ state.result.expression = expression;
60
+ }
55
61
  const value = evaluate(ast, state);
56
62
  return value;
57
63
  }
@@ -71,10 +77,39 @@ export class EvalService extends BaseEval {
71
77
  * @param options The evaluation options.
72
78
  * @returns A promise that resolves to the result of the evaluation.
73
79
  */
74
- evalAsync(expression, context, options) {
80
+ simpleEvalAsync(expression, context, options) {
75
81
  try {
76
82
  const ast = this.parse(expression);
77
- const state = EvalState.fromContext(context, options);
83
+ const state = this.createState(context, options);
84
+ if (state?.result && typeof expression === 'string') {
85
+ state.result.expression = expression;
86
+ }
87
+ const promise = evaluateAsync(ast, state);
88
+ return promise;
89
+ }
90
+ catch (error) {
91
+ if (error instanceof Error) {
92
+ throw new Error(error.message);
93
+ }
94
+ else {
95
+ throw error;
96
+ }
97
+ }
98
+ }
99
+ /**
100
+ * Asynchronously evaluates an expression using the provided state.
101
+ *
102
+ * @param expression - The expression to evaluate. Can be a string or an AST node.
103
+ * @param state - The evaluation state.
104
+ * @returns A promise that resolves to the result of the evaluation.
105
+ * @throws If an error occurs during evaluation.
106
+ */
107
+ evalAsync(expression, state) {
108
+ try {
109
+ const ast = this.parse(expression);
110
+ if (state?.result && typeof expression === 'string') {
111
+ state.result.expression = expression;
112
+ }
78
113
  const promise = evaluateAsync(ast, state);
79
114
  return promise;
80
115
  }
@@ -96,4 +131,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImpor
96
131
  providedIn: 'root'
97
132
  }]
98
133
  }], ctorParameters: () => [{ type: i1.ParserService }] });
99
- //# sourceMappingURL=data:application/json;base64,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
134
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eval.service.js","sourceRoot":"","sources":["../../../../../../../modules/eval-core/src/lib/actual/services/eval.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { BaseEval } from './base-eval';\r\nimport { ParserService } from './parser.service';\r\nimport { AnyNode } from 'acorn';\r\nimport { Context } from '../../internal/classes/common';\r\nimport { EvalContext, EvalOptions, EvalState, defaultParserOptions } from '../../internal/classes/eval';\r\nimport { evaluate, evaluateAsync } from '../../internal/functions';\r\n\r\n/**\r\n * Service for evaluating and parsing expressions.\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class EvalService extends BaseEval {\r\n\r\n  /**\r\n   * Constructs a new instance of the EvalService class.\r\n   * @param parserService The parser service used for parsing expressions.\r\n   */\r\n  constructor(\r\n    protected override parserService: ParserService\r\n  ) {\r\n    super(parserService);\r\n    this.parserOptions = defaultParserOptions;\r\n  }\r\n\r\n  /**\r\n   * Evaluates the given expression.\r\n   * @param expression The expression to evaluate.\r\n   * @param context The evaluation context.\r\n   * @param options The evaluation options.\r\n   * @returns The result of the evaluation.\r\n   */\r\n  simpleEval(expression: string | AnyNode | undefined,\r\n             context?: EvalContext | Context,\r\n             options?: EvalOptions\r\n  ): unknown | undefined {\r\n    try {\r\n      const ast = this.parse(expression);\r\n      const state = this.createState(context, options);\r\n      if (state?.result && typeof expression === 'string') {\r\n        state.result.expression = expression;\r\n      }\r\n      const value = evaluate(ast, state);\r\n      return value;\r\n    } catch (error) {\r\n      if (error instanceof Error) {\r\n        throw new Error(error.message);\r\n      } else {\r\n        throw error;\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Evaluates an expression using the provided state.\r\n   *\r\n   * @param expression - The expression to evaluate.\r\n   * @param state - The state object containing variables and functions used in the evaluation.\r\n   * @returns The result of the evaluation.\r\n   * @throws If an error occurs during evaluation.\r\n   */\r\n  eval(expression: string | AnyNode | undefined,\r\n       state: EvalState\r\n  ): unknown | undefined {\r\n    try {\r\n      const ast = this.parse(expression);\r\n      if (state?.result && typeof expression === 'string') {\r\n        state.result.expression = expression;\r\n      }\r\n      const value = evaluate(ast, state);\r\n      return value;\r\n    } catch (error) {\r\n      if (error instanceof Error) {\r\n        throw new Error(error.message);\r\n      } else {\r\n        throw error;\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Asynchronously evaluates the given expression.\r\n   * @param expression The expression to evaluate.\r\n   * @param context The evaluation context.\r\n   * @param options The evaluation options.\r\n   * @returns A promise that resolves to the result of the evaluation.\r\n   */\r\n  simpleEvalAsync(expression: string | AnyNode | undefined,\r\n                  context?: EvalContext | Context,\r\n                  options?: EvalOptions\r\n  ): Promise<unknown | undefined> {\r\n    try {\r\n      const ast = this.parse(expression);\r\n      const state = this.createState(context, options);\r\n      if (state?.result && typeof expression === 'string') {\r\n        state.result.expression = expression;\r\n      }\r\n      const promise = evaluateAsync(ast, state);\r\n      return promise;\r\n    } catch (error) {\r\n      if (error instanceof Error) {\r\n        throw new Error(error.message);\r\n      } else {\r\n        throw error;\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Asynchronously evaluates an expression using the provided state.\r\n   *\r\n   * @param expression - The expression to evaluate. Can be a string or an AST node.\r\n   * @param state - The evaluation state.\r\n   * @returns A promise that resolves to the result of the evaluation.\r\n   * @throws If an error occurs during evaluation.\r\n   */\r\n  evalAsync(expression: string | AnyNode | undefined,\r\n            state: EvalState\r\n  ): Promise<unknown | undefined> {\r\n    try {\r\n      const ast = this.parse(expression);\r\n      if (state?.result && typeof expression === 'string') {\r\n        state.result.expression = expression;\r\n      }\r\n      const promise = evaluateAsync(ast, state);\r\n      return promise;\r\n    } catch (error) {\r\n      if (error instanceof Error) {\r\n        throw new Error(error.message);\r\n      } else {\r\n        throw error;\r\n      }\r\n    }\r\n  }\r\n\r\n}\r\n\r\n\r\n"]}
@@ -1,24 +1,34 @@
1
1
  import { Injectable } from '@angular/core';
2
- import { BaseEval } from './base-eval';
3
2
  import { Cache } from '../../internal/classes/common';
4
- import { defaultOptions, version as acornVersion } from 'acorn';
3
+ import { version as acornVersion } from 'acorn';
5
4
  import { parse as _parse } from '../../internal/functions';
5
+ import { defaultParserOptions } from '../../internal/classes/eval';
6
6
  import * as i0 from "@angular/core";
7
7
  /**
8
8
  * @description
9
9
  * Service for parsing expressions and returning ES6/ES2020 AST.
10
10
  */
11
- export class ParserService extends BaseEval {
11
+ export class ParserService {
12
+ /**
13
+ * Gets the parser options.
14
+ */
15
+ get parserOptions() {
16
+ return this._parserOptions;
17
+ }
18
+ /**
19
+ * Sets the parser options.
20
+ * @param value The parser options to set.
21
+ */
22
+ set parserOptions(value) {
23
+ this._parserOptions = value;
24
+ }
12
25
  /**
13
26
  * Constructs a new instance of the ParserService class.
14
27
  */
15
28
  constructor() {
16
- super();
17
29
  this.parserOptions = {
18
- ...defaultOptions,
19
- ecmaVersion: 2020,
20
- extractExpressions: true,
21
- cacheSize: 100
30
+ ...defaultParserOptions,
31
+ extractExpressions: true
22
32
  };
23
33
  if (this.parserOptions.cacheSize) {
24
34
  this._cache = new Cache(this.parserOptions.cacheSize);
@@ -88,4 +98,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImpor
88
98
  providedIn: 'root'
89
99
  }]
90
100
  }], ctorParameters: () => [] });
91
- //# sourceMappingURL=data:application/json;base64,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
101
+ //# sourceMappingURL=data:application/json;base64,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