@journeyapps/evaluator - npm Package Compare versions

Comparing version 0.0.0-dev.20439a3 to 0.0.0-dev.209c1e3

dist/@types/FormatString.d.ts

@@ -5,2 +5,5 @@ import { AttributeValidationError } from '@journeyapps/core-xml';
 import { TokenExpression } from './token-expressions';
+export interface FormatStringOptions {
+    expression: string;
+}
 /**
@@ -14,4 +17,5 @@ * Construct a new format string expression.
     tokens: TokenExpression[];
-    constructor(expression: string);
     static isInstanceOf(val: any): val is FormatString;
+    constructor(options: FormatStringOptions);
+    static fromTokens(tokens: TokenExpression[]): FormatString;
     /**
@@ -43,4 +47,8 @@ * Compile a format string expression into tokens.
     };
+    /**
+     * Removes one set of curly braces from the string.
+     * Example {{foo}} -> {foo}
+     */
     static unescape(s: string): string;
 }
 export declare const parseEnclosingBraces: typeof FormatString.parseEnclosingBraces;

dist/@types/index.d.ts

 export * from './parsers';
 export * from './TokenExpressionParser';
+export * from './context/ParseContext';
+export * from './context/FormatStringContext';
+export * from './context/FunctionExpressionContext';
 export * from './FormatString';
@@ -7,4 +10,5 @@ export * from './token-expressions';
 export * from './definitions/ObjectRefInterface';
+export * from './definitions/VariableScope';
+export * from './definitions/VariableFormatStringScope';
 export * from './definitions/FormatStringScope';
-export * from './scope/VariableFormatStringScope';
 export * from './tools';

dist/@types/parsers/AbstractExpressionParser.d.ts

 import { Node, Aliases } from '@babel/types';
 import { TokenExpression } from '../token-expressions';
+import { ParseNodeEvent } from '../TokenExpressionParser';
 export type NodeType = Node['type'] | keyof Aliases;
-export interface ExpressionNodeEvent<N extends Node = Node> {
-    source: string;
-    node: N;
-    parseNode(node: Node, source: string): TokenExpression | null;
+export interface ExpressionNodeParseEvent<N extends Node = Node> extends ParseNodeEvent<N> {
+    parseNode(event: ParseNodeEvent): TokenExpression | null;
 }
-export interface AbstractExpressionParserOptions {
-}
-export declare abstract class AbstractExpressionParser<N extends Node = Node, T extends TokenExpression = TokenExpression, O extends AbstractExpressionParserOptions = AbstractExpressionParserOptions, E extends ExpressionNodeEvent<N> = ExpressionNodeEvent<N>> {
-    options: O;
-    constructor(options?: O);
+export declare abstract class AbstractExpressionParser<N extends Node = Node, T extends TokenExpression = TokenExpression, E extends ExpressionNodeParseEvent<N> = ExpressionNodeParseEvent<N>> {
     abstract parse(event: E): T;
@@ -15,0 +10,0 @@ }

dist/@types/parsers/BlockStatementParser.d.ts

@@ -1,6 +0,8 @@
-import { BlockStatement, Statement } from '@babel/types';
-import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeEvent } from './AbstractExpressionParser';
+import { BlockStatement } from '@babel/types';
+import { ConstantTokenExpression } from '../token-expressions';
+import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeParseEvent } from './AbstractExpressionParser';
 export declare class BlockStatementParser extends AbstractExpressionParser<BlockStatement> {
-    parse(event: ExpressionNodeEvent<BlockStatement>): import("../token-expressions").TokenExpression<import("../token-expressions").TokenExpressionOptions, any>;
-    getFormatSpecifier(stm: Statement | null): string;
+    parse(event: ExpressionNodeParseEvent<BlockStatement>): import("../token-expressions").TokenExpression<import("../token-expressions").TokenExpressionOptions, any> | ConstantTokenExpression<{
+        expression: string;
+    }>;
 }
@@ -7,0 +9,0 @@ export declare class BlockStatementParserFactory extends ExpressionParserFactory<BlockStatementParser> {

dist/@types/parsers/CallExpressionParser.d.ts

 import { CallExpression } from '@babel/types';
 import { FunctionTokenExpression } from '../token-expressions';
-import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeEvent } from './AbstractExpressionParser';
+import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeParseEvent } from './AbstractExpressionParser';
 export declare class CallExpressionParser extends AbstractExpressionParser<CallExpression, FunctionTokenExpression> {
-    parse(event: ExpressionNodeEvent<CallExpression>): FunctionTokenExpression;
+    parse(event: ExpressionNodeParseEvent<CallExpression>): FunctionTokenExpression<{
+        expression: string;
+        name: string;
+        arguments: import("../token-expressions").TokenExpression<import("../token-expressions").TokenExpressionOptions, any>[];
+    }>;
 }
@@ -7,0 +11,0 @@ export declare class CallExpressionParserFactory extends ExpressionParserFactory<CallExpressionParser> {

dist/@types/parsers/ConditionalExpressionParser.d.ts

 import { ConditionalExpression } from '@babel/types';
 import { FunctionTokenExpression } from '../token-expressions';
-import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeEvent } from './AbstractExpressionParser';
+import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeParseEvent } from './AbstractExpressionParser';
 export declare class ConditionalExpressionParser extends AbstractExpressionParser<ConditionalExpression, FunctionTokenExpression> {
-    parse(event: ExpressionNodeEvent<ConditionalExpression>): FunctionTokenExpression;
+    parse(event: ExpressionNodeParseEvent<ConditionalExpression>): FunctionTokenExpression;
 }
@@ -7,0 +7,0 @@ export declare class ConditionalExpressionParserFactory extends ExpressionParserFactory<ConditionalExpressionParser> {

dist/@types/parsers/ExpressionNodeParser.d.ts

 import { Directive, ExpressionStatement, LabeledStatement } from '@babel/types';
-import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeEvent } from './AbstractExpressionParser';
+import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeParseEvent } from './AbstractExpressionParser';
 export type ExpressionType = ExpressionStatement | Directive | LabeledStatement;
 export declare class ExpressionNodeParser extends AbstractExpressionParser<ExpressionType> {
-    parse(event: ExpressionNodeEvent<ExpressionType>): import("..").TokenExpression<import("..").TokenExpressionOptions, any>;
+    parse(event: ExpressionNodeParseEvent<ExpressionType>): import("..").TokenExpression<import("..").TokenExpressionOptions, any>;
 }
@@ -7,0 +7,0 @@ export declare class ExpressionNodeParserFactory extends ExpressionParserFactory<ExpressionNodeParser> {

dist/@types/parsers/IdentifierExpressionParser.d.ts

 import { Identifier } from '@babel/types';
 import { FormatShorthandTokenExpression, FunctionTokenExpression, ShorthandTokenExpression } from '../token-expressions';
-import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeEvent } from './AbstractExpressionParser';
-export type IdentifierExpressionParsedType = FunctionTokenExpression | ShorthandTokenExpression | FormatShorthandTokenExpression;
-export declare class IdentifierExpressionParser extends AbstractExpressionParser<Identifier, IdentifierExpressionParsedType> {
-    parse(event: ExpressionNodeEvent<Identifier>): FunctionTokenExpression | ShorthandTokenExpression<import("../token-expressions").TokenExpressionOptions>;
+import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeParseEvent } from './AbstractExpressionParser';
+export type ParsedIdentifierExpressionType = FunctionTokenExpression | ShorthandTokenExpression | FormatShorthandTokenExpression;
+export declare class IdentifierExpressionParser extends AbstractExpressionParser<Identifier, ParsedIdentifierExpressionType> {
+    parse(event: ExpressionNodeParseEvent<Identifier>): FunctionTokenExpression<{
+        expression: string;
+    }> | ShorthandTokenExpression<{
+        expression: string;
+    }>;
 }
@@ -8,0 +12,0 @@ export declare class IdentifierExpressionParserFactory extends ExpressionParserFactory<IdentifierExpressionParser> {

dist/@types/parsers/index.d.ts

 export * from './AbstractExpressionParser';
+export * from './ArrayExpressionParser';
 export * from './BlockStatementParser';
@@ -8,3 +9,4 @@ export * from './CallExpressionParser';
 export * from './LiteralExpressionParser';
+export * from './LogicalExpressionParser';
 export * from './MemberExpressionParser';
 export * from './ObjectExpressionParser';

dist/@types/parsers/LiteralExpressionParser.d.ts

 import { DirectiveLiteral, Literal } from '@babel/types';
-import { ConstantTokenExpression, PrimitiveConstantTokenExpression } from '../token-expressions';
-import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeEvent } from './AbstractExpressionParser';
+import { ConstantTokenExpression, FunctionTokenExpression, PrimitiveConstantTokenExpression } from '../token-expressions';
+import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeParseEvent } from './AbstractExpressionParser';
 export type LiteralExpression = Literal | DirectiveLiteral;
-export declare class LiteralExpressionParser extends AbstractExpressionParser<LiteralExpression, ConstantTokenExpression> {
-    parse(event: ExpressionNodeEvent<LiteralExpression>): ConstantTokenExpression | PrimitiveConstantTokenExpression;
+export type ParsedLiteralExpressionType = ConstantTokenExpression | FunctionTokenExpression | PrimitiveConstantTokenExpression;
+export declare class LiteralExpressionParser extends AbstractExpressionParser<LiteralExpression, ParsedLiteralExpressionType> {
+    parse(event: ExpressionNodeParseEvent<LiteralExpression>): PrimitiveConstantTokenExpression | FunctionTokenExpression<{
+        expression: string;
+    }> | ConstantTokenExpression<{
+        expression: string;
+    }>;
 }
@@ -8,0 +13,0 @@ export declare class LiteralExpressionParserFactory extends ExpressionParserFactory<LiteralExpressionParser> {

dist/@types/parsers/MemberExpressionParser.d.ts

 import { MemberExpression } from '@babel/types';
-import { FormatShorthandTokenExpression, FunctionTokenExpression, ShorthandTokenExpression } from '../token-expressions';
-import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeEvent } from './AbstractExpressionParser';
+import { FormatShorthandTokenExpression, FunctionTokenExpression, ShorthandTokenExpression, ShorthandTokenExpressionOptions, TokenExpression } from '../token-expressions';
+import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeParseEvent } from './AbstractExpressionParser';
 export type MemberExpressionParsedType = FunctionTokenExpression | ShorthandTokenExpression | FormatShorthandTokenExpression;
+/**
+ * Parses member expressions like:
+ *
+ * object.property1
+ * object[param].property2
+ * object['property1'].property2
+ */
 export declare class MemberExpressionParser extends AbstractExpressionParser<MemberExpression, MemberExpressionParsedType> {
-    parse(event: ExpressionNodeEvent<MemberExpression>): FunctionTokenExpression | ShorthandTokenExpression<import("../token-expressions").TokenExpressionOptions>;
+    parse(event: ExpressionNodeParseEvent<MemberExpression>): ShorthandTokenExpression<ShorthandTokenExpressionOptions> | FunctionTokenExpression<ShorthandTokenExpressionOptions>;
+    static parseMember(event: ExpressionNodeParseEvent<MemberExpression>, properties?: TokenExpression[]): {
+        objectName: string;
+        properties: TokenExpression[];
+    };
 }
@@ -8,0 +19,0 @@ export declare class MemberExpressionParserFactory extends ExpressionParserFactory<MemberExpressionParser> {

dist/@types/parsers/ObjectExpressionParser.d.ts

 import { ObjectExpression } from '@babel/types';
 import { ObjectTokenExpression } from '../token-expressions';
-import { AbstractExpressionParser, ExpressionParserFactory, ExpressionNodeEvent } from './AbstractExpressionParser';
+import { AbstractExpressionParser, ExpressionNodeParseEvent, ExpressionParserFactory } from './AbstractExpressionParser';
 export declare class ObjectExpressionParser extends AbstractExpressionParser<ObjectExpression, ObjectTokenExpression> {
-    parse(event: ExpressionNodeEvent<ObjectExpression>): ObjectTokenExpression;
+    parse(event: ExpressionNodeParseEvent<ObjectExpression>): ObjectTokenExpression;
 }
@@ -7,0 +7,0 @@ export declare class ObjectExpressionParserFactory extends ExpressionParserFactory<ObjectExpressionParser> {

dist/@types/token-expressions/constant/ConstantTokenExpression.d.ts

@@ -6,4 +6,6 @@ /**
 import { FormatStringScope } from '../../definitions/FormatStringScope';
-export declare class ConstantTokenExpression extends TokenExpression {
-    constructor(expression: string, options?: TokenExpressionOptions);
+export declare class ConstantTokenExpression<O extends TokenExpressionOptions = TokenExpressionOptions> extends TokenExpression<O> {
+    static TYPE: string;
+    static isInstanceOf(obj: any): obj is ConstantTokenExpression;
+    constructor(options: O);
     /**
@@ -13,2 +15,3 @@ * Concatenate a token to current token and return a new token.
     concat(token: ConstantTokenExpression): ConstantTokenExpression;
+    tokenEvaluatePromise(scope: FormatStringScope): Promise<string>;
     /**
@@ -18,3 +21,4 @@ * Get the value of the constant token expression.
     valueOf(): string;
-    tokenEvaluatePromise(scope: FormatStringScope): Promise<string>;
+    stringify(): string;
+    clone(): this;
 }

dist/@types/token-expressions/constant/PrimitiveConstantTokenExpression.d.ts

@@ -6,8 +6,17 @@ /**
 import { TokenExpressionOptions } from '../TokenExpression';
-export declare class PrimitiveConstantTokenExpression extends ConstantTokenExpression {
-    constructor(expression: any, options?: TokenExpressionOptions);
+export interface PrimitiveConstantTokenExpressionOptions extends TokenExpressionOptions {
+    expression: any;
+    isNullLiteral?: boolean;
+}
+export declare class PrimitiveConstantTokenExpression extends ConstantTokenExpression<PrimitiveConstantTokenExpressionOptions> {
+    static readonly TYPE = "primitive-constant-expression";
+    static isInstanceOf(obj: any): obj is PrimitiveConstantTokenExpression;
+    constructor(options: PrimitiveConstantTokenExpressionOptions);
+    isNullLiteral(): boolean;
     /**
-     * Get the value of the constant token expression.
+     * Concatenate a token to current token and return a new token.
      */
-    valueOf(): any;
+    concat(token: ConstantTokenExpression): ConstantTokenExpression;
+    stringify(): string;
+    clone(): this;
 }

dist/@types/token-expressions/index.d.ts

 export * from './TokenExpression';
-export * from './ObjectTokenExpression';
-export * from './ShorthandTokenExpression';
-export * from './FormatShorthandTokenExpression';
+export * from './object/ObjectTokenExpression';
+export * from './object/ArrayTokenExpression';
+export * from './shorthand/ShorthandTokenExpression';
+export * from './shorthand/FormatShorthandTokenExpression';
 export * from './constant/PrimitiveConstantTokenExpression';
 export * from './constant/ConstantTokenExpression';
-export * from './function-token/FunctionTokenExpression';
-export * from './function-token/LegacyFunctionTokenExpression';
+export * from './function/FunctionTokenExpression';
+export * from './function/TernaryFunctionTokenExpression';
+export * from './function/LegacyFunctionTokenExpression';

dist/@types/token-expressions/TokenExpression.d.ts

 import { FormatStringScope } from '../definitions/FormatStringScope';
 export interface TokenExpressionOptions {
+    expression: string;
     start?: number;
@@ -12,12 +13,15 @@ format?: string;
     isFunction?: boolean;
+    isComputed?: boolean;
 }
 export declare abstract class TokenExpression<O extends TokenExpressionOptions = TokenExpressionOptions, V extends any = any> {
+    type: string;
     expression: string;
     options: O;
-    protected constructor(expression: string, options?: O);
+    isPrimitive: boolean;
+    protected constructor(type: string, options: O);
     abstract tokenEvaluatePromise(scope: FormatStringScope): Promise<V>;
+    abstract clone(): this;
     get start(): number | null;
     set start(start: number);
     get format(): string | null;
-    get isPrimitive(): boolean;
     isConstant(): boolean;
@@ -24,0 +28,0 @@ isShorthand(): boolean;

dist/@types/TokenExpressionParser.d.ts

 /// <reference types="lodash" />
 import { Node } from '@babel/types';
-import { ExpressionParserFactory, NodeType, AbstractExpressionParser } from './parsers';
+import LRUCache from 'lru-cache';
+import { ParseContext, ParseContextFactory } from './context/ParseContext';
+import { AbstractExpressionParser, ExpressionParserFactory, NodeType } from './parsers';
 import { TokenExpression } from './token-expressions';
+export interface TokenExpressionParseEvent {
+    source: string;
+    context?: ParseContext;
+}
+export interface ParseNodeEvent<N extends Node = Node> extends TokenExpressionParseEvent {
+    node: N;
+}
 export declare class TokenExpressionParser {
-    factories: ExpressionParserFactory[];
-    static FORMAT_SPECIFIER_IDENTIFIER: string;
+    cache: LRUCache<string, TokenExpression>;
+    parserFactories: ExpressionParserFactory[];
+    contextFactories: ParseContextFactory[];
     static instance: TokenExpressionParser;
     static get(): TokenExpressionParser;
     constructor();
-    parse<T extends TokenExpression = TokenExpression>(source: string): T | null;
-    parseNode(node: Node, source: string): TokenExpression | null;
-    registerFactory(factory: ExpressionParserFactory): void;
+    parse<T extends TokenExpression = TokenExpression>(event: TokenExpressionParseEvent): T | null;
+    parseNode(event: ParseNodeEvent): TokenExpression | null;
+    registerParserFactory(factory: ExpressionParserFactory): void;
+    registerContextFactory(factory: ParseContextFactory): void;
+    transformSource(event: TokenExpressionParseEvent): string;
     getParser: ((nodeType: NodeType) => AbstractExpressionParser) & import("lodash").MemoizedFunction;
-    private preprocess;
+    inferContext(source: string): ParseContext | null;
 }

dist/@types/tools.d.ts

@@ -11,3 +11,3 @@ import { TypeInterface } from './definitions/TypeInterface';
  */
-export declare function functionTokenExpression(expression: string, allowLegacy?: boolean): FunctionTokenExpression | LegacyFunctionTokenExpression;
+export declare function functionTokenExpression(expression: string, allowLegacy?: boolean): FunctionTokenExpression<import("./token-expressions").FunctionTokenExpressionOptions> | LegacyFunctionTokenExpression;
 /**
@@ -14,0 +14,0 @@ * Create a token expression that can be evaluated.

dist/index.js

@@ -19,2 +19,5 @@ "use strict";
 __exportStar(require("./TokenExpressionParser"), exports);
+__exportStar(require("./context/ParseContext"), exports);
+__exportStar(require("./context/FormatStringContext"), exports);
+__exportStar(require("./context/FunctionExpressionContext"), exports);
 __exportStar(require("./FormatString"), exports);
@@ -24,5 +27,6 @@ __exportStar(require("./token-expressions"), exports);
 __exportStar(require("./definitions/ObjectRefInterface"), exports);
+__exportStar(require("./definitions/VariableScope"), exports);
+__exportStar(require("./definitions/VariableFormatStringScope"), exports);
 __exportStar(require("./definitions/FormatStringScope"), exports);
-__exportStar(require("./scope/VariableFormatStringScope"), exports);
 __exportStar(require("./tools"), exports);
 //# sourceMappingURL=index.js.map

package.json

 {
   "name": "@journeyapps/evaluator",
-  "version": "0.0.0-dev.20439a3",
+  "version": "0.0.0-dev.209c1e3",
   "description": "Journey Evaluator library",
@@ -8,4 +8,3 @@ "main": "./dist/index.js",
   "files": [
-    "dist/src",
-    "dist/@types"
+    "dist"
   ],
@@ -15,4 +14,5 @@ "dependencies": {
     "@babel/parser": "^7.24.5",
+    "lru-cache": "^7.18.3",
     "lodash": "^4.17.21",
-    "@journeyapps/core-xml": "0.0.0-dev.20439a3"
+    "@journeyapps/core-xml": "0.0.0-dev.209c1e3"
   },
@@ -19,0 +19,0 @@ "devDependencies": {

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

287975

493.11%

Number of package files

123

296.77%

Lines of code

2338

426.58%

Worsened metrics

Dependency count

5

25%

Dependency changes

• + Added

  lru-cache@^7.18.3

• + Added

  @journeyapps/core-xml@0.0.0-dev.209c1e3
  (transitive)

• + Added

  lru-cache@7.18.3
  (transitive)

• - Removed

  @journeyapps/core-xml@0.0.0-dev.20439a3
  (transitive)

• Updated

  @journeyapps/core-xml@0.0.0-dev.209c1e3