src/util/conditionalExpression.ts - echarts - Git at Google

 /*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

 import { OptionDataValue, DimensionLoose, Dictionary } from './types';
 import {
     keys, isArray, map, isObject, isString, HashMap, isRegExp, isArrayLike, hasOwn
 } from 'zrender/src/core/util';
 import { throwError, makePrintable } from './log';
 import {
     RawValueParserType, getRawValueParser,
     RelationalOperator, FilterComparator, createFilterComparator
 } from '../data/helper/dataValueHelper';


 // PENDING:
 // (1) Support more parser like: `parser: 'trim'`, `parser: 'lowerCase'`, `parser: 'year'`, `parser: 'dayOfWeek'`?
 // (2) Support piped parser ?
 // (3) Support callback parser or callback condition?
 // (4) At present do not support string expression yet but only stuctured expression.


 /**
  * The structured expression considered:
  * (1) Literal simplicity
  * (2) Sementic displayed clearly
  *
  * Sementic supports:
  * (1) relational expression
  * (2) logical expression
  *
  * For example:
  * ```js
  * {
  *     and: [{
  *         or: [{
  *             dimension: 'Year', gt: 2012, lt: 2019
  *         }, {
  *             dimension: 'Year', '>': 2002, '<=': 2009
  *         }]
  *     }, {
  *         dimension: 'Product', eq: 'Tofu'
  *     }]
  * }
  *
  * { dimension: 'Product', eq: 'Tofu' }
  *
  * {
  *     or: [
  *         { dimension: 'Product', value: 'Tofu' },
  *         { dimension: 'Product', value: 'Biscuit' }
  *     ]
  * }
  *
  * {
  *     and: [true]
  * }
  * ```
  *
  * [PARSER]
  * In an relation expression object, we can specify some built-in parsers:
  * ```js
  * // Trim if string
  * {
  *     parser: 'trim',
  *     eq: 'Flowers'
  * }
  * // Parse as time and enable arithmetic relation comparison.
  * {
  *     parser: 'time',
  *     lt: '2012-12-12'
  * }
  * // Normalize number-like string and make '-' to Null.
  * {
  *     parser: 'time',
  *     lt: '2012-12-12'
  * }
  * // Normalize to number:
  * // + number-like string (like '  123  ') can be converted to a number.
  * // + where null/undefined or other string will be converted to NaN.
  * {
  *     parser: 'number',
  *     eq: 2011
  * }
  * // RegExp, include the feature in SQL: `like '%xxx%'`.
  * {
  *     reg: /^asdf$/
  * }
  * {
  *     reg: '^asdf$' // Serializable reg exp, will be `new RegExp(...)`
  * }
  * ```
  *
  *
  * [EMPTY_RULE]
  * (1) If a relational expression set value as `null`/`undefined` like:
  * `{ dimension: 'Product', lt: undefined }`,
  * The result will be `false` rather than `true`.
  * Consider the case like "filter condition", return all result when null/undefined
  * is probably not expected and even dangours.
  * (2) If a relational expression has no operator like:
  * `{ dimension: 'Product' }`,
  * An error will be thrown. Because it is probably a mistake.
  * (3) If a logical expression has no children like
  * `{ and: undefined }` or `{ and: [] }`,
  * An error will be thrown. Because it is probably an mistake.
  * (4) If intending have a condition that always `true` or always `false`,
  * Use `true` or `flase`.
  * The entire condition can be `true`/`false`,
  * or also can be `{ and: [true] }`, `{ or: [false] }`
  */


 // --------------------------------------------------
 // --- Relational Expression --------------------------
 // --------------------------------------------------

 /**
  * Date string and ordinal string can be accepted.
  */
 interface RelationalExpressionOptionByOp extends Record<RelationalOperator, OptionDataValue> {
     reg?: RegExp | string; // RegExp
 };
 const RELATIONAL_EXPRESSION_OP_ALIAS_MAP = {
     value: 'eq',

     // PENDING: not good for literal semantic?
     '<': 'lt',
     '<=': 'lte',
     '>': 'gt',
     '>=': 'gte',
     '=': 'eq',
     '!=': 'ne',
     '<>': 'ne'

     // Might mileading for sake of the different between '==' and '===',
     // So dont support them.
     // '==': 'eq',
     // '===': 'seq',
     // '!==': 'sne'

     // PENDING: Whether support some common alias "ge", "le", "neq"?
     // ge: 'gte',
     // le: 'lte',
     // neq: 'ne',
 } as const;
 type RelationalExpressionOptionByOpAlias = Record<keyof typeof RELATIONAL_EXPRESSION_OP_ALIAS_MAP, OptionDataValue>;

 interface RelationalExpressionOption extends
         RelationalExpressionOptionByOp, RelationalExpressionOptionByOpAlias {
     dimension?: DimensionLoose;
     parser?: RawValueParserType;
 }

 type RelationalExpressionOpEvaluate = (tarVal: unknown, condVal: unknown) => boolean;


 class RegExpEvaluator implements FilterComparator {
     private _condVal: RegExp;

     constructor(rVal: unknown) {
         // Support condVal: RegExp | string
         const condValue = this._condVal = isString(rVal) ? new RegExp(rVal)
             : isRegExp(rVal) ? rVal as RegExp
             : null;
         if (condValue == null) {
             let errMsg = '';
             if (__DEV__) {
                 errMsg = makePrintable('Illegal regexp', rVal, 'in');
             }
             throwError(errMsg);
         }
     }

     evaluate(lVal: unknown): boolean {
         const type = typeof lVal;
         return type === 'string' ? this._condVal.test(lVal as string)
             : type === 'number' ? this._condVal.test(lVal + '')
             : false;
     }
 }


 // --------------------------------------------------
 // --- Logical Expression ---------------------------
 // --------------------------------------------------


 interface LogicalExpressionOption {
     and?: LogicalExpressionSubOption[];
     or?: LogicalExpressionSubOption[];
     not?: LogicalExpressionSubOption;
 }
 type LogicalExpressionSubOption =
     LogicalExpressionOption | RelationalExpressionOption | TrueFalseExpressionOption;


 // -----------------------------------------------------
 // --- Conditional Expression --------------------------
 // -----------------------------------------------------


 export type TrueExpressionOption = true;
 export type FalseExpressionOption = false;
 export type TrueFalseExpressionOption = TrueExpressionOption | FalseExpressionOption;

 export type ConditionalExpressionOption =
     LogicalExpressionOption
     | RelationalExpressionOption
     | TrueFalseExpressionOption;

 type ValueGetterParam = Dictionary<unknown>;
 export interface ConditionalExpressionValueGetterParamGetter<VGP extends ValueGetterParam = ValueGetterParam> {
     (relExpOption: RelationalExpressionOption): VGP
 }
 export interface ConditionalExpressionValueGetter<VGP extends ValueGetterParam = ValueGetterParam> {
     (param: VGP): OptionDataValue
 }

 interface ParsedConditionInternal {
     evaluate(): boolean;
 }
 class ConstConditionInternal implements ParsedConditionInternal {
     value: boolean;
     evaluate(): boolean {
         return this.value;
     }
 }
 class AndConditionInternal implements ParsedConditionInternal {
     children: ParsedConditionInternal[];
     evaluate() {
         const children = this.children;
         for (let i = 0; i < children.length; i++) {
             if (!children[i].evaluate()) {
                 return false;
             }
         }
         return true;
     }
 }
 class OrConditionInternal implements ParsedConditionInternal {
     children: ParsedConditionInternal[];
     evaluate() {
         const children = this.children;
         for (let i = 0; i < children.length; i++) {
             if (children[i].evaluate()) {
                 return true;
             }
         }
         return false;
     }
 }
 class NotConditionInternal implements ParsedConditionInternal {
     child: ParsedConditionInternal;
     evaluate() {
         return !this.child.evaluate();
     }
 }
 class RelationalConditionInternal implements ParsedConditionInternal {
     valueGetterParam: ValueGetterParam;
     valueParser: ReturnType<typeof getRawValueParser>;
     // If no parser, be null/undefined.
     getValue: ConditionalExpressionValueGetter;
     subCondList: FilterComparator[];

     evaluate() {
         const needParse = !!this.valueParser;
         // Call getValue with no `this`.
         const getValue = this.getValue;
         const tarValRaw = getValue(this.valueGetterParam);
         const tarValParsed = needParse ? this.valueParser(tarValRaw) : null;

         // Relational cond follow "and" logic internally.
         for (let i = 0; i < this.subCondList.length; i++) {
             if (!this.subCondList[i].evaluate(needParse ? tarValParsed : tarValRaw)) {
                 return false;
             }
         }
         return true;
     }
 }

 function parseOption(
     exprOption: ConditionalExpressionOption,
     getters: ConditionalGetters
 ): ParsedConditionInternal {
     if (exprOption === true || exprOption === false) {
         const cond = new ConstConditionInternal();
         cond.value = exprOption as boolean;
         return cond;
     }

     let errMsg = '';
     if (!isObjectNotArray(exprOption)) {
         if (__DEV__) {
             errMsg = makePrintable(
                 'Illegal config. Expect a plain object but actually', exprOption
             );
         }
         throwError(errMsg);
     }

     if ((exprOption as LogicalExpressionOption).and) {
         return parseAndOrOption('and', exprOption as LogicalExpressionOption, getters);
     }
     else if ((exprOption as LogicalExpressionOption).or) {
         return parseAndOrOption('or', exprOption as LogicalExpressionOption, getters);
     }
     else if ((exprOption as LogicalExpressionOption).not) {
         return parseNotOption(exprOption as LogicalExpressionOption, getters);
     }

     return parseRelationalOption(exprOption as RelationalExpressionOption, getters);
 }

 function parseAndOrOption(
     op: 'and' | 'or',
     exprOption: LogicalExpressionOption,
     getters: ConditionalGetters
 ): ParsedConditionInternal {
     const subOptionArr = exprOption[op] as ConditionalExpressionOption[];
     let errMsg = '';
     if (__DEV__) {
         errMsg = makePrintable(
             '"and"/"or" condition should only be `' + op + ': [...]` and must not be empty array.',
             'Illegal condition:', exprOption
         );
     }
     if (!isArray(subOptionArr)) {
         throwError(errMsg);
     }
     if (!(subOptionArr as []).length) {
         throwError(errMsg);
     }
     const cond = op === 'and' ? new AndConditionInternal() : new OrConditionInternal();
     cond.children = map(subOptionArr, subOption => parseOption(subOption, getters));
     if (!cond.children.length) {
         throwError(errMsg);
     }
     return cond;
 }

 function parseNotOption(
     exprOption: LogicalExpressionOption,
     getters: ConditionalGetters
 ): ParsedConditionInternal {
     const subOption = exprOption.not as ConditionalExpressionOption;
     let errMsg = '';
     if (__DEV__) {
         errMsg = makePrintable(
             '"not" condition should only be `not: {}`.',
             'Illegal condition:', exprOption
         );
     }
     if (!isObjectNotArray(subOption)) {
         throwError(errMsg);
     }
     const cond = new NotConditionInternal();
     cond.child = parseOption(subOption, getters);
     if (!cond.child) {
         throwError(errMsg);
     }
     return cond;
 }

 function parseRelationalOption(
     exprOption: RelationalExpressionOption,
     getters: ConditionalGetters
 ): ParsedConditionInternal {
     let errMsg = '';

     const valueGetterParam = getters.prepareGetValue(exprOption);

     const subCondList = [] as RelationalConditionInternal['subCondList'];
     const exprKeys = keys(exprOption);

     const parserName = exprOption.parser;
     const valueParser = parserName ? getRawValueParser(parserName) : null;

     for (let i = 0; i < exprKeys.length; i++) {
         const keyRaw = exprKeys[i];
         if (keyRaw === 'parser' || getters.valueGetterAttrMap.get(keyRaw)) {
             continue;
         }

         const op: keyof RelationalExpressionOptionByOp = hasOwn(RELATIONAL_EXPRESSION_OP_ALIAS_MAP, keyRaw)
             ? RELATIONAL_EXPRESSION_OP_ALIAS_MAP[keyRaw as keyof RelationalExpressionOptionByOpAlias]
             : (keyRaw as keyof RelationalExpressionOptionByOp);
         const condValueRaw = exprOption[keyRaw];
         const condValueParsed = valueParser ? valueParser(condValueRaw) : condValueRaw;
         const evaluator = createFilterComparator(op, condValueParsed)
             || (op === 'reg' && new RegExpEvaluator(condValueParsed));

         if (!evaluator) {
             if (__DEV__) {
                 errMsg = makePrintable(
                     'Illegal relational operation: "' + keyRaw + '" in condition:', exprOption
                 );
             }
             throwError(errMsg);
         }

         subCondList.push(evaluator);
     }

     if (!subCondList.length) {
         if (__DEV__) {
             errMsg = makePrintable(
                 'Relational condition must have at least one operator.',
                 'Illegal condition:', exprOption
             );
         }
         // No relational operator always disabled in case of dangers result.
         throwError(errMsg);
     }

     const cond = new RelationalConditionInternal();
     cond.valueGetterParam = valueGetterParam;
     cond.valueParser = valueParser;
     cond.getValue = getters.getValue;
     cond.subCondList = subCondList;

     return cond;
 }

 function isObjectNotArray(val: unknown): boolean {
     return isObject(val) && !isArrayLike(val);
 }


 class ConditionalExpressionParsed {

     private _cond: ParsedConditionInternal;

     constructor(
         exprOption: ConditionalExpressionOption,
         getters: ConditionalGetters
     ) {
         this._cond = parseOption(exprOption, getters);
     }

     evaluate(): boolean {
         return this._cond.evaluate();
     }
 };

 interface ConditionalGetters<VGP extends ValueGetterParam = ValueGetterParam> {
     prepareGetValue: ConditionalExpressionValueGetterParamGetter<VGP>;
     getValue: ConditionalExpressionValueGetter<VGP>;
     valueGetterAttrMap: HashMap<boolean, string>;
 }

 export function parseConditionalExpression<VGP extends ValueGetterParam = ValueGetterParam>(
     exprOption: ConditionalExpressionOption,
     getters: ConditionalGetters<VGP>
 ): ConditionalExpressionParsed {
     return new ConditionalExpressionParsed(exprOption, getters);
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	import { OptionDataValue, DimensionLoose, Dictionary } from './types';
	import {
	keys, isArray, map, isObject, isString, HashMap, isRegExp, isArrayLike, hasOwn
	} from 'zrender/src/core/util';
	import { throwError, makePrintable } from './log';
	import {
	RawValueParserType, getRawValueParser,
	RelationalOperator, FilterComparator, createFilterComparator
	} from '../data/helper/dataValueHelper';


	// PENDING:
	// (1) Support more parser like: `parser: 'trim'`, `parser: 'lowerCase'`, `parser: 'year'`, `parser: 'dayOfWeek'`?
	// (2) Support piped parser ?
	// (3) Support callback parser or callback condition?
	// (4) At present do not support string expression yet but only stuctured expression.


	/**
	* The structured expression considered:
	* (1) Literal simplicity
	* (2) Sementic displayed clearly
	*
	* Sementic supports:
	* (1) relational expression
	* (2) logical expression
	*
	* For example:
	* ```js
	* {
	* and: [{
	* or: [{
	* dimension: 'Year', gt: 2012, lt: 2019
	* }, {
	* dimension: 'Year', '>': 2002, '<=': 2009
	* }]
	* }, {
	* dimension: 'Product', eq: 'Tofu'
	* }]
	* }
	*
	* { dimension: 'Product', eq: 'Tofu' }
	*
	* {
	* or: [
	* { dimension: 'Product', value: 'Tofu' },
	* { dimension: 'Product', value: 'Biscuit' }
	* ]
	* }
	*
	* {
	* and: [true]
	* }
	* ```
	*
	* [PARSER]
	* In an relation expression object, we can specify some built-in parsers:
	* ```js
	* // Trim if string
	* {
	* parser: 'trim',
	* eq: 'Flowers'
	* }
	* // Parse as time and enable arithmetic relation comparison.
	* {
	* parser: 'time',
	* lt: '2012-12-12'
	* }
	* // Normalize number-like string and make '-' to Null.
	* {
	* parser: 'time',
	* lt: '2012-12-12'
	* }
	* // Normalize to number:
	* // + number-like string (like ' 123 ') can be converted to a number.
	* // + where null/undefined or other string will be converted to NaN.
	* {
	* parser: 'number',
	* eq: 2011
	* }
	* // RegExp, include the feature in SQL: `like '%xxx%'`.
	* {
	* reg: /^asdf$/
	* }
	* {
	* reg: '^asdf$' // Serializable reg exp, will be `new RegExp(...)`
	* }
	* ```
	*
	*
	* [EMPTY_RULE]
	* (1) If a relational expression set value as `null`/`undefined` like:
	* `{ dimension: 'Product', lt: undefined }`,
	* The result will be `false` rather than `true`.
	* Consider the case like "filter condition", return all result when null/undefined
	* is probably not expected and even dangours.
	* (2) If a relational expression has no operator like:
	* `{ dimension: 'Product' }`,
	* An error will be thrown. Because it is probably a mistake.
	* (3) If a logical expression has no children like
	* `{ and: undefined }` or `{ and: [] }`,
	* An error will be thrown. Because it is probably an mistake.
	* (4) If intending have a condition that always `true` or always `false`,
	* Use `true` or `flase`.
	* The entire condition can be `true`/`false`,
	* or also can be `{ and: [true] }`, `{ or: [false] }`
	*/


	// --------------------------------------------------
	// --- Relational Expression --------------------------
	// --------------------------------------------------

	/**
	* Date string and ordinal string can be accepted.
	*/
	interface RelationalExpressionOptionByOp extends Record<RelationalOperator, OptionDataValue> {
	reg?: RegExp \| string; // RegExp
	};
	const RELATIONAL_EXPRESSION_OP_ALIAS_MAP = {
	value: 'eq',

	// PENDING: not good for literal semantic?
	'<': 'lt',
	'<=': 'lte',
	'>': 'gt',
	'>=': 'gte',
	'=': 'eq',
	'!=': 'ne',
	'<>': 'ne'

	// Might mileading for sake of the different between '==' and '===',
	// So dont support them.
	// '==': 'eq',
	// '===': 'seq',
	// '!==': 'sne'

	// PENDING: Whether support some common alias "ge", "le", "neq"?
	// ge: 'gte',
	// le: 'lte',
	// neq: 'ne',
	} as const;
	type RelationalExpressionOptionByOpAlias = Record<keyof typeof RELATIONAL_EXPRESSION_OP_ALIAS_MAP, OptionDataValue>;

	interface RelationalExpressionOption extends
	RelationalExpressionOptionByOp, RelationalExpressionOptionByOpAlias {
	dimension?: DimensionLoose;
	parser?: RawValueParserType;
	}

	type RelationalExpressionOpEvaluate = (tarVal: unknown, condVal: unknown) => boolean;


	class RegExpEvaluator implements FilterComparator {
	private _condVal: RegExp;

	constructor(rVal: unknown) {
	// Support condVal: RegExp \| string
	const condValue = this._condVal = isString(rVal) ? new RegExp(rVal)
	: isRegExp(rVal) ? rVal as RegExp
	: null;
	if (condValue == null) {
	let errMsg = '';
	if (__DEV__) {
	errMsg = makePrintable('Illegal regexp', rVal, 'in');
	}
	throwError(errMsg);
	}
	}

	evaluate(lVal: unknown): boolean {
	const type = typeof lVal;
	return type === 'string' ? this._condVal.test(lVal as string)
	: type === 'number' ? this._condVal.test(lVal + '')
	: false;
	}
	}




	// --------------------------------------------------
	// --- Logical Expression ---------------------------
	// --------------------------------------------------


	interface LogicalExpressionOption {
	and?: LogicalExpressionSubOption[];
	or?: LogicalExpressionSubOption[];
	not?: LogicalExpressionSubOption;
	}
	type LogicalExpressionSubOption =
	LogicalExpressionOption \| RelationalExpressionOption \| TrueFalseExpressionOption;



	// -----------------------------------------------------
	// --- Conditional Expression --------------------------
	// -----------------------------------------------------


	export type TrueExpressionOption = true;
	export type FalseExpressionOption = false;
	export type TrueFalseExpressionOption = TrueExpressionOption \| FalseExpressionOption;

	export type ConditionalExpressionOption =
	LogicalExpressionOption
	\| RelationalExpressionOption
	\| TrueFalseExpressionOption;

	type ValueGetterParam = Dictionary<unknown>;
	export interface ConditionalExpressionValueGetterParamGetter<VGP extends ValueGetterParam = ValueGetterParam> {
	(relExpOption: RelationalExpressionOption): VGP
	}
	export interface ConditionalExpressionValueGetter<VGP extends ValueGetterParam = ValueGetterParam> {
	(param: VGP): OptionDataValue
	}

	interface ParsedConditionInternal {
	evaluate(): boolean;
	}
	class ConstConditionInternal implements ParsedConditionInternal {
	value: boolean;
	evaluate(): boolean {
	return this.value;
	}
	}
	class AndConditionInternal implements ParsedConditionInternal {
	children: ParsedConditionInternal[];
	evaluate() {
	const children = this.children;
	for (let i = 0; i < children.length; i++) {
	if (!children[i].evaluate()) {
	return false;
	}
	}
	return true;
	}
	}
	class OrConditionInternal implements ParsedConditionInternal {
	children: ParsedConditionInternal[];
	evaluate() {
	const children = this.children;
	for (let i = 0; i < children.length; i++) {
	if (children[i].evaluate()) {
	return true;
	}
	}
	return false;
	}
	}
	class NotConditionInternal implements ParsedConditionInternal {
	child: ParsedConditionInternal;
	evaluate() {
	return !this.child.evaluate();
	}
	}
	class RelationalConditionInternal implements ParsedConditionInternal {
	valueGetterParam: ValueGetterParam;
	valueParser: ReturnType<typeof getRawValueParser>;
	// If no parser, be null/undefined.
	getValue: ConditionalExpressionValueGetter;
	subCondList: FilterComparator[];

	evaluate() {
	const needParse = !!this.valueParser;
	// Call getValue with no `this`.
	const getValue = this.getValue;
	const tarValRaw = getValue(this.valueGetterParam);
	const tarValParsed = needParse ? this.valueParser(tarValRaw) : null;

	// Relational cond follow "and" logic internally.
	for (let i = 0; i < this.subCondList.length; i++) {
	if (!this.subCondList[i].evaluate(needParse ? tarValParsed : tarValRaw)) {
	return false;
	}
	}
	return true;
	}
	}

	function parseOption(
	exprOption: ConditionalExpressionOption,
	getters: ConditionalGetters
	): ParsedConditionInternal {
	if (exprOption === true \|\| exprOption === false) {
	const cond = new ConstConditionInternal();
	cond.value = exprOption as boolean;
	return cond;
	}

	let errMsg = '';
	if (!isObjectNotArray(exprOption)) {
	if (__DEV__) {
	errMsg = makePrintable(
	'Illegal config. Expect a plain object but actually', exprOption
	);
	}
	throwError(errMsg);
	}

	if ((exprOption as LogicalExpressionOption).and) {
	return parseAndOrOption('and', exprOption as LogicalExpressionOption, getters);
	}
	else if ((exprOption as LogicalExpressionOption).or) {
	return parseAndOrOption('or', exprOption as LogicalExpressionOption, getters);
	}
	else if ((exprOption as LogicalExpressionOption).not) {
	return parseNotOption(exprOption as LogicalExpressionOption, getters);
	}

	return parseRelationalOption(exprOption as RelationalExpressionOption, getters);
	}

	function parseAndOrOption(
	op: 'and' \| 'or',
	exprOption: LogicalExpressionOption,
	getters: ConditionalGetters
	): ParsedConditionInternal {
	const subOptionArr = exprOption[op] as ConditionalExpressionOption[];
	let errMsg = '';
	if (__DEV__) {
	errMsg = makePrintable(
	'"and"/"or" condition should only be `' + op + ': [...]` and must not be empty array.',
	'Illegal condition:', exprOption
	);
	}
	if (!isArray(subOptionArr)) {
	throwError(errMsg);
	}
	if (!(subOptionArr as []).length) {
	throwError(errMsg);
	}
	const cond = op === 'and' ? new AndConditionInternal() : new OrConditionInternal();
	cond.children = map(subOptionArr, subOption => parseOption(subOption, getters));
	if (!cond.children.length) {
	throwError(errMsg);
	}
	return cond;
	}

	function parseNotOption(
	exprOption: LogicalExpressionOption,
	getters: ConditionalGetters
	): ParsedConditionInternal {
	const subOption = exprOption.not as ConditionalExpressionOption;
	let errMsg = '';
	if (__DEV__) {
	errMsg = makePrintable(
	'"not" condition should only be `not: {}`.',
	'Illegal condition:', exprOption
	);
	}
	if (!isObjectNotArray(subOption)) {
	throwError(errMsg);
	}
	const cond = new NotConditionInternal();
	cond.child = parseOption(subOption, getters);
	if (!cond.child) {
	throwError(errMsg);
	}
	return cond;
	}

	function parseRelationalOption(
	exprOption: RelationalExpressionOption,
	getters: ConditionalGetters
	): ParsedConditionInternal {
	let errMsg = '';

	const valueGetterParam = getters.prepareGetValue(exprOption);

	const subCondList = [] as RelationalConditionInternal['subCondList'];
	const exprKeys = keys(exprOption);

	const parserName = exprOption.parser;
	const valueParser = parserName ? getRawValueParser(parserName) : null;

	for (let i = 0; i < exprKeys.length; i++) {
	const keyRaw = exprKeys[i];
	if (keyRaw === 'parser' \|\| getters.valueGetterAttrMap.get(keyRaw)) {
	continue;
	}

	const op: keyof RelationalExpressionOptionByOp = hasOwn(RELATIONAL_EXPRESSION_OP_ALIAS_MAP, keyRaw)
	? RELATIONAL_EXPRESSION_OP_ALIAS_MAP[keyRaw as keyof RelationalExpressionOptionByOpAlias]
	: (keyRaw as keyof RelationalExpressionOptionByOp);
	const condValueRaw = exprOption[keyRaw];
	const condValueParsed = valueParser ? valueParser(condValueRaw) : condValueRaw;
	const evaluator = createFilterComparator(op, condValueParsed)
	\|\| (op === 'reg' && new RegExpEvaluator(condValueParsed));

	if (!evaluator) {
	if (__DEV__) {
	errMsg = makePrintable(
	'Illegal relational operation: "' + keyRaw + '" in condition:', exprOption
	);
	}
	throwError(errMsg);
	}

	subCondList.push(evaluator);
	}

	if (!subCondList.length) {
	if (__DEV__) {
	errMsg = makePrintable(
	'Relational condition must have at least one operator.',
	'Illegal condition:', exprOption
	);
	}
	// No relational operator always disabled in case of dangers result.
	throwError(errMsg);
	}

	const cond = new RelationalConditionInternal();
	cond.valueGetterParam = valueGetterParam;
	cond.valueParser = valueParser;
	cond.getValue = getters.getValue;
	cond.subCondList = subCondList;

	return cond;
	}

	function isObjectNotArray(val: unknown): boolean {
	return isObject(val) && !isArrayLike(val);
	}


	class ConditionalExpressionParsed {

	private _cond: ParsedConditionInternal;

	constructor(
	exprOption: ConditionalExpressionOption,
	getters: ConditionalGetters
	) {
	this._cond = parseOption(exprOption, getters);
	}

	evaluate(): boolean {
	return this._cond.evaluate();
	}
	};

	interface ConditionalGetters<VGP extends ValueGetterParam = ValueGetterParam> {
	prepareGetValue: ConditionalExpressionValueGetterParamGetter<VGP>;
	getValue: ConditionalExpressionValueGetter<VGP>;
	valueGetterAttrMap: HashMap<boolean, string>;
	}

	export function parseConditionalExpression<VGP extends ValueGetterParam = ValueGetterParam>(
	exprOption: ConditionalExpressionOption,
	getters: ConditionalGetters<VGP>
	): ConditionalExpressionParsed {
	return new ConditionalExpressionParsed(exprOption, getters);
	}