@mojir/lits 2.0.4 → 2.0.6

package/dist/src/Lits/Lits.d.ts

@@ -23,8 +23,6 @@ export interface LitsParams {
     lazyValues?: Record<string, LazyValue>;
     jsFunctions?: Record<string, JsFunction>;
     filePath?: string;
-    debug?: boolean;
-    algebraic?: boolean;
 }
 interface LitsConfig {
     initialCache?: Record<string, Ast>;
@@ -42,12 +40,13 @@ export declare class Lits {
     run(program: string, params?: LitsParams): unknown;
     context(program: string, params?: LitsParams): Context;
     analyze(program: string, params?: LitsParams): Analysis;
-    tokenize(program: string, tokenizeParams?: TokenizeParams): TokenStream;
+    tokenize(program: string, tokenizeParams?: Pick<TokenizeParams, 'filePath'>): TokenStream;
     parse(tokenStream: TokenStream): Ast;
     evaluate(ast: Ast, params: LitsParams): Any;
     transform(tokenStream: TokenStream, transformer: (name: string) => string): TokenStream;
     untokenize(tokenStream: TokenStream): string;
     apply(fn: LitsFunction, fnParams: unknown[], params?: LitsParams): Any;
+    private generateApplyFunctionCall;
     private generateAst;
 }
 export {};

package/dist/src/tokenizer/interface.d.ts

@@ -16,7 +16,7 @@ export interface TokenStream {
     filePath?: string;
 }
 export interface TokenizeParams {
-    debug?: boolean;
+    debug: boolean;
+    algebraic: boolean;
     filePath?: string;
-    algebraic?: boolean;
 }

package/dist/testFramework.esm.js

@@ -3123,7 +3123,7 @@ var mathNormalExpression = {
     },
 };
 
-var version = "2.0.4";
+var version = "2.0.6";
 
 var uuidTemplate = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
 var xyRegexp = /[xy]/g;
@@ -7345,14 +7345,22 @@ var AlgebraicParser = /** @class */ (function () {
                 return parseReservedSymbol(this.tokenStream, this.parseState);
             case 'PolNotation': {
                 this.parseState.algebraic = false;
-                var astNode = void 0;
+                var astNodes = [];
                 this.advance();
                 do {
-                    astNode = this.parseState.parseToken(this.tokenStream, this.parseState);
+                    astNodes.push(this.parseState.parseToken(this.tokenStream, this.parseState));
                 } while (!isEndNotationToken(this.peek()));
                 this.advance();
                 this.parseState.algebraic = true;
-                return astNode;
+                if (astNodes.length === 1) {
+                    return astNodes[0];
+                }
+                return {
+                    t: AstNodeType.SpecialExpression,
+                    n: 'do',
+                    p: astNodes,
+                    token: getTokenDebugData(token) && token,
+                };
             }
             case 'AlgNotation': {
                 this.advance();
@@ -7847,13 +7855,21 @@ function parsePolishToken(tokenStream, parseState) {
             return node;
         }
         case 'PolNotation': {
-            var node = void 0;
+            var astNodes = [];
             parseState.position += 1;
             do {
-                node = parsePolishToken(tokenStream, parseState);
+                astNodes.push(parsePolishToken(tokenStream, parseState));
             } while (!isEndNotationToken(asToken(tokenStream.tokens[parseState.position])));
             parseState.position += 1;
-            return node;
+            if (astNodes.length === 1) {
+                return astNodes[0];
+            }
+            return {
+                t: AstNodeType.SpecialExpression,
+                n: 'do',
+                p: astNodes,
+                token: astNodes[0].token,
+            };
         }
         case 'P_CollectionAccessor':
         case 'P_Modifier':
@@ -8773,10 +8789,9 @@ var Lits = /** @class */ (function () {
         return analyze(ast, params);
     };
     Lits.prototype.tokenize = function (program, tokenizeParams) {
-        var _a, _b;
         if (tokenizeParams === void 0) { tokenizeParams = {}; }
-        var debug = (_a = tokenizeParams.debug) !== null && _a !== void 0 ? _a : this.debug;
-        var algebraic = (_b = tokenizeParams.algebraic) !== null && _b !== void 0 ? _b : this.algebraic;
+        var debug = this.debug;
+        var algebraic = this.algebraic;
         return tokenize(program, __assign(__assign({}, tokenizeParams), { debug: debug, algebraic: algebraic }));
     };
     Lits.prototype.parse = function (tokenStream) {
@@ -8796,12 +8811,7 @@ var Lits = /** @class */ (function () {
         var _a;
         if (params === void 0) { params = {}; }
         var fnName = 'FN_2eb7b316-471c-5bfa-90cb-d3dfd9164a59';
-        var paramsString = fnParams
-            .map(function (_, index) {
-            return "".concat(fnName, "_").concat(index);
-        })
-            .join(' ');
-        var program = "(".concat(fnName, " ").concat(paramsString, ")");
+        var program = this.generateApplyFunctionCall(fnName, fnParams);
         var ast = this.generateAst(program, params);
         var hostValues = fnParams.reduce(function (result, param, index) {
             result["".concat(fnName, "_").concat(index)] = param;
@@ -8810,20 +8820,26 @@ var Lits = /** @class */ (function () {
         params.values = __assign(__assign({}, params.values), hostValues);
         return this.evaluate(ast, params);
     };
+    Lits.prototype.generateApplyFunctionCall = function (fnName, fnParams) {
+        var paramsString = fnParams
+            .map(function (_, index) {
+            return "".concat(fnName, "_").concat(index);
+        })
+            .join(this.algebraic ? ', ' : ' ');
+        return this.algebraic ? "".concat(fnName, "(").concat(paramsString, ")") : "(".concat(fnName, " ").concat(paramsString, ")");
+    };
     Lits.prototype.generateAst = function (program, params) {
-        var _a, _b, _c;
+        var _a;
         if (this.astCache) {
             var cachedAst = this.astCache.get(program);
             if (cachedAst)
                 return cachedAst;
         }
         var tokenStream = this.tokenize(program, {
-            debug: (_a = params.debug) !== null && _a !== void 0 ? _a : this.debug,
             filePath: params.filePath,
-            algebraic: (_b = params.algebraic) !== null && _b !== void 0 ? _b : this.algebraic,
         });
         var ast = this.parse(tokenStream);
-        (_c = this.astCache) === null || _c === void 0 ? void 0 : _c.set(program, ast);
+        (_a = this.astCache) === null || _a === void 0 ? void 0 : _a.set(program, ast);
         return ast;
     };
     return Lits;