@briza/illogical 1.4.3 → 1.5.2

package/types/expression/logical/xor.d.ts

@@ -1,27 +1,23 @@
-/**
- * Logical expression module.
- * @module illogical/expression/logical
- */
-import { Context, Evaluable, Result } from '../../common/evaluable';
-import { Logical } from '../logical';
-export declare const OPERATOR: unique symbol;
-/**
- * Xor logical expression
- */
-export declare class Xor extends Logical {
-    /**
-     * @constructor
-     * @param {Evaluable[]} operands Collection of operands.
-     */
-    constructor(operands: Evaluable[]);
-    /**
-     * Evaluate in the given context.
-     * @param {Context} ctx
-     * @return {Result}
-     */
-    evaluate(ctx: Context): Result;
-    /**
-     * {@link Evaluable.simplify}
-     */
-    simplify(...args: [Context, string[]]): boolean | Evaluable;
-}
+import { Context, Evaluable, Result, SimplifyArgs } from '../../common/evaluable';
+import { Logical } from '../logical';
+export declare const OPERATOR: unique symbol;
+/**
+ * Xor logical expression
+ */
+export declare class Xor extends Logical {
+    /**
+     * @constructor
+     * @param {Evaluable[]} operands Collection of operands.
+     */
+    constructor(operands: Evaluable[]);
+    /**
+     * Evaluate in the given context.
+     * @param {Context} ctx
+     * @return {Result}
+     */
+    evaluate(ctx: Context): Result;
+    /**
+     * {@link Evaluable.simplify}
+     */
+    simplify(...args: SimplifyArgs): boolean | Evaluable;
+}

package/types/index.d.ts

@@ -1,71 +1,73 @@
-/**
- * Main module.
- * @module illogical
- */
-import { Context, Evaluable } from './common/evaluable';
-import { OPERATOR as OPERATOR_EQ } from './expression/comparison/eq';
-import { OPERATOR as OPERATOR_GE } from './expression/comparison/ge';
-import { OPERATOR as OPERATOR_GT } from './expression/comparison/gt';
-import { OPERATOR as OPERATOR_IN } from './expression/comparison/in';
-import { OPERATOR as OPERATOR_LE } from './expression/comparison/le';
-import { OPERATOR as OPERATOR_LT } from './expression/comparison/lt';
-import { OPERATOR as OPERATOR_NE } from './expression/comparison/ne';
-import { OPERATOR as OPERATOR_NOT_IN } from './expression/comparison/not-in';
-import { OPERATOR as OPERATOR_OVERLAP } from './expression/comparison/overlap';
-import { OPERATOR as OPERATOR_PREFIX } from './expression/comparison/prefix';
-import { OPERATOR as OPERATOR_PRESENT } from './expression/comparison/present';
-import { OPERATOR as OPERATOR_SUFFIX } from './expression/comparison/suffix';
-import { OPERATOR as OPERATOR_UNDEFINED } from './expression/comparison/undefined';
-import { OPERATOR as OPERATOR_AND } from './expression/logical/and';
-import { OPERATOR as OPERATOR_NOR } from './expression/logical/nor';
-import { OPERATOR as OPERATOR_NOT } from './expression/logical/not';
-import { OPERATOR as OPERATOR_OR } from './expression/logical/or';
-import { OPERATOR as OPERATOR_XOR } from './expression/logical/xor';
-import { ExpressionInput, Input } from './parser';
-import { Options } from './parser/options';
-export { OPERATOR_EQ, OPERATOR_NE, OPERATOR_GT, OPERATOR_GE, OPERATOR_LT, OPERATOR_LE, OPERATOR_IN, OPERATOR_NOT_IN, OPERATOR_PREFIX, OPERATOR_SUFFIX, OPERATOR_OVERLAP, OPERATOR_UNDEFINED, OPERATOR_PRESENT, OPERATOR_AND, OPERATOR_OR, OPERATOR_NOR, OPERATOR_XOR, OPERATOR_NOT, };
-/**
- * Condition engine
- */
-declare class Engine {
-    private readonly parser;
-    /**
-     * @constructor
-     * @param {Options?} options Parser options.
-     */
-    constructor(options?: Partial<Options>);
-    /**
-     * Evaluate the expression.
-     * @param {ExpressionInput} exp Raw expression.
-     * @param {Context} ctx Evaluation data context.
-     * @return {boolean}
-     */
-    evaluate(exp: ExpressionInput, ctx: Context): boolean;
-    /**
-     * Get expression statement
-     * @param {ExpressionInput} exp Raw expression.
-     * @return {string}
-     */
-    statement(exp: ExpressionInput): string;
-    /**
-     * Parse expression.
-     * @param {ExpressionInput} exp Raw expression.
-     * @return {Evaluable}
-     */
-    parse(exp: ExpressionInput): Evaluable;
-    /**
-     * Simplifies an expression with values in context.
-     *
-     * This method tries to evaluate all the expressions and reduce them to its corresponding boolean value.
-     * If a value required for the expression is not present in the context, the minimal corresponding expression
-     * will be returned.
-     *
-     * @param {ExpressionInput} exp  Raw expression.
-     * @param {Context} context Evaluation data context.
-     * @param {string[]} ignoreKeys keys to be considered present even if their not present in the context.
-     *  Default to empty array
-     * @returns {Inpunt | boolean}
-     */
-    simplify(exp: ExpressionInput, context: Context, ignoreKeys?: string[]): Input | boolean;
-}
-export default Engine;
+/**
+ * Main module.
+ * @module illogical
+ */
+import { Context, Evaluable } from './common/evaluable';
+import { OPERATOR as OPERATOR_EQ } from './expression/comparison/eq';
+import { OPERATOR as OPERATOR_GE } from './expression/comparison/ge';
+import { OPERATOR as OPERATOR_GT } from './expression/comparison/gt';
+import { OPERATOR as OPERATOR_IN } from './expression/comparison/in';
+import { OPERATOR as OPERATOR_LE } from './expression/comparison/le';
+import { OPERATOR as OPERATOR_LT } from './expression/comparison/lt';
+import { OPERATOR as OPERATOR_NE } from './expression/comparison/ne';
+import { OPERATOR as OPERATOR_NOT_IN } from './expression/comparison/not-in';
+import { OPERATOR as OPERATOR_OVERLAP } from './expression/comparison/overlap';
+import { OPERATOR as OPERATOR_PREFIX } from './expression/comparison/prefix';
+import { OPERATOR as OPERATOR_PRESENT } from './expression/comparison/present';
+import { OPERATOR as OPERATOR_SUFFIX } from './expression/comparison/suffix';
+import { OPERATOR as OPERATOR_UNDEFINED } from './expression/comparison/undefined';
+import { OPERATOR as OPERATOR_AND } from './expression/logical/and';
+import { OPERATOR as OPERATOR_NOR } from './expression/logical/nor';
+import { OPERATOR as OPERATOR_NOT } from './expression/logical/not';
+import { OPERATOR as OPERATOR_OR } from './expression/logical/or';
+import { OPERATOR as OPERATOR_XOR } from './expression/logical/xor';
+import { ExpressionInput, Input } from './parser';
+import { Options } from './parser/options';
+export { OPERATOR_EQ, OPERATOR_NE, OPERATOR_GT, OPERATOR_GE, OPERATOR_LT, OPERATOR_LE, OPERATOR_IN, OPERATOR_NOT_IN, OPERATOR_PREFIX, OPERATOR_SUFFIX, OPERATOR_OVERLAP, OPERATOR_UNDEFINED, OPERATOR_PRESENT, OPERATOR_AND, OPERATOR_OR, OPERATOR_NOR, OPERATOR_XOR, OPERATOR_NOT, };
+/**
+ * Condition engine
+ */
+declare class Engine {
+    private readonly parser;
+    /**
+     * @constructor
+     * @param {Options?} options Parser options.
+     */
+    constructor(options?: Partial<Options>);
+    /**
+     * Evaluate the expression.
+     * @param {ExpressionInput} exp Raw expression.
+     * @param {Context} ctx Evaluation data context.
+     * @return {boolean}
+     */
+    evaluate(exp: ExpressionInput, ctx: Context): boolean;
+    /**
+     * Get expression statement
+     * @param {ExpressionInput} exp Raw expression.
+     * @return {string}
+     */
+    statement(exp: ExpressionInput): string;
+    /**
+     * Parse expression.
+     * @param {ExpressionInput} exp Raw expression.
+     * @return {Evaluable}
+     */
+    parse(exp: ExpressionInput): Evaluable;
+    /**
+     * Simplifies an expression with values in context.
+     *
+     * This method tries to evaluate all the expressions and reduce them to its corresponding boolean value.
+     * If a value required for the expression is not present in the context, the minimal corresponding expression
+     * will be returned.
+     *
+     * @param {ExpressionInput} exp  Raw expression.
+     * @param {Context} context Evaluation data context.
+     * @param {string[]} strictKeys keys to be considered present even if they are not present in the context
+     * @param {string[]} optionalKeys keys to be considered not present unless they are in the context or in
+     *  `strictKeys`; when `strictKeys` is `undefined` and `optionalKeys` is an array, every key that is not in
+     *  `optionalKeys` is considered to be present and thus will be evaluated
+     * @returns {Inpunt | boolean}
+     */
+    simplify(exp: ExpressionInput, context: Context, strictKeys?: string[], optionalKeys?: string[]): Input | boolean;
+}
+export default Engine;

package/types/operand/collection.d.ts

@@ -1,40 +1,36 @@
-/**
- * Operand module.
- * @module illogical/operand
- */
-import { Context, Evaluable, Result } from '../common/evaluable';
-import { Input } from '../parser';
-import { Options } from '../parser/options';
-import { Operand } from '.';
-import { Reference } from './reference';
-import { Value } from './value';
-/**
- * Collection operand resolved containing mixture of value and references.
- */
-export declare class Collection extends Operand {
-    private readonly items;
-    /**
-     * @constructor
-     * @param {Operand[]} items Collection of operands.
-     */
-    constructor(items: Array<Value | Reference>);
-    /**
-     * Evaluate in the given context.
-     * @param {Context} ctx
-     * @return {boolean}
-     */
-    evaluate(ctx: Context): Result;
-    /**
-     * {@link Evaluable.simplify}
-     */
-    simplify(...args: [Context, string[]]): Result | Evaluable;
-    /**
-     * {@link Evaluable.serialize}
-     */
-    serialize(options: Options): Input;
-    /**
-     * Get the strict representation of the operand.
-     * @return {string}
-     */
-    toString(): string;
-}
+import { Context, Evaluable, Result, SimplifyArgs } from '../common/evaluable';
+import { Input } from '../parser';
+import { Options } from '../parser/options';
+import { Operand } from '.';
+import { Reference } from './reference';
+import { Value } from './value';
+/**
+ * Collection operand resolved containing mixture of value and references.
+ */
+export declare class Collection extends Operand {
+    private readonly items;
+    /**
+     * @constructor
+     * @param {Operand[]} items Collection of operands.
+     */
+    constructor(items: Array<Value | Reference>);
+    /**
+     * Evaluate in the given context.
+     * @param {Context} ctx
+     * @return {boolean}
+     */
+    evaluate(ctx: Context): Result;
+    /**
+     * {@link Evaluable.simplify}
+     */
+    simplify(...args: SimplifyArgs): Result | Evaluable;
+    /**
+     * {@link Evaluable.serialize}
+     */
+    serialize(options: Options): Input;
+    /**
+     * Get the strict representation of the operand.
+     * @return {string}
+     */
+    toString(): string;
+}

package/types/operand/index.d.ts

@@ -1,29 +1,25 @@
-/**
- * Operand module.
- * @module illogical/operand
- */
-import { Context, Evaluable, EvaluableType, Result } from '../common/evaluable';
-import { Input } from '../parser';
-import { Options } from '../parser/options';
-/**
- * Abstract operand
- */
-export declare abstract class Operand implements Evaluable {
-    type: EvaluableType;
-    /**
-     * {@link Evaluable.evaluate}
-     */
-    abstract evaluate(ctx: Context): Result;
-    /**
-     * {@link Evaluable.simplify}
-     */
-    abstract simplify(ctx: Context, ignoreKeys: string[]): Result | Evaluable;
-    /**
-     * {@link Evaluable.serialize}
-     */
-    abstract serialize(options: Options): Input;
-    /**
-     * Get the strict representation.
-     */
-    toString(): string;
-}
+import { Context, Evaluable, EvaluableType, Result } from '../common/evaluable';
+import { Input } from '../parser';
+import { Options } from '../parser/options';
+/**
+ * Abstract operand
+ */
+export declare abstract class Operand implements Evaluable {
+    type: EvaluableType;
+    /**
+     * {@link Evaluable.evaluate}
+     */
+    abstract evaluate(ctx: Context): Result;
+    /**
+     * {@link Evaluable.simplify}
+     */
+    abstract simplify(ctx: Context, strictKeys?: string[], optionalKeys?: string[]): Result | Evaluable;
+    /**
+     * {@link Evaluable.serialize}
+     */
+    abstract serialize(options: Options): Input;
+    /**
+     * Get the strict representation.
+     */
+    toString(): string;
+}

package/types/operand/reference.d.ts

@@ -1,48 +1,44 @@
-/**
- * Operand module.
- * @module illogical/operand
- */
-import { Context, Evaluable, Result } from '../common/evaluable';
-import { Options } from '../parser/options';
-import { Operand } from '.';
-export declare enum DataType {
-    Number = "Number",
-    String = "String"
-}
-/**
- * Reference operand resolved within the context
- */
-export declare class Reference extends Operand {
-    private readonly key;
-    private readonly dataType;
-    /**
-     * @constructor
-     * @param {string} key Context key.
-     */
-    constructor(key: string);
-    /**
-     * Evaluate in the given context.
-     * @param {Context} ctx
-     * @return {boolean}
-     */
-    evaluate(ctx: Context): Result;
-    /**
-     * {@link Evaluable.simplify}
-     */
-    simplify(ctx: Context, ignoreKeys: string[]): Result | Evaluable;
-    /**
-     * {@link Evaluable.serialize}
-     */
-    serialize({ referenceSerialization }: Options): string;
-    /**
-     * Get the strict representation of the operand.
-     * @return {string}
-     */
-    toString(): string;
-    /**
-     * Converts a value to a specified data type
-     * Silently returns original value if data type conversion has not been implemented.
-     * @param value value to cast as data type
-     */
-    private toDataType;
-}
+import { Context, Evaluable, Result } from '../common/evaluable';
+import { Options } from '../parser/options';
+import { Operand } from '.';
+export declare enum DataType {
+    Number = "Number",
+    String = "String"
+}
+/**
+ * Reference operand resolved within the context
+ */
+export declare class Reference extends Operand {
+    private readonly key;
+    private readonly dataType;
+    /**
+     * @constructor
+     * @param {string} key Context key.
+     */
+    constructor(key: string);
+    /**
+     * Evaluate in the given context.
+     * @param {Context} ctx
+     * @return {boolean}
+     */
+    evaluate(ctx: Context): Result;
+    /**
+     * {@link Evaluable.simplify}
+     */
+    simplify(ctx: Context, strictKeys?: string[], optionalKeys?: string[]): Result | Evaluable;
+    /**
+     * {@link Evaluable.serialize}
+     */
+    serialize({ referenceSerialization }: Options): string;
+    /**
+     * Get the strict representation of the operand.
+     * @return {string}
+     */
+    toString(): string;
+    /**
+     * Converts a value to a specified data type
+     * Silently returns original value if data type conversion has not been implemented.
+     * @param value value to cast as data type
+     */
+    private toDataType;
+}

package/types/operand/value.d.ts

@@ -1,35 +1,31 @@
-/**
- * Operand module.
- * @module illogical/operand
- */
-import { Result } from '../common/evaluable';
-import { Input } from '../parser';
-import { Operand } from '.';
-/**
- * Static value operand
- */
-export declare class Value extends Operand {
-    private readonly value;
-    /**
-     * @constructor
-     * @param {Result} value Constant value.
-     */
-    constructor(value: Result);
-    /**
-     * {@link Evaluable.evaluate}
-     */
-    evaluate(): Result;
-    /**
-     * {@link Evaluable.simplify}
-     */
-    simplify(): Result;
-    /**
-     * {@link Evaluable.serialize}
-     */
-    serialize(): Input;
-    /**
-     * Get the strict representation of the operand.
-     * @return {string}
-     */
-    toString(): string;
-}
+import { Result } from '../common/evaluable';
+import { Input } from '../parser';
+import { Operand } from '.';
+/**
+ * Static value operand
+ */
+export declare class Value extends Operand {
+    private readonly value;
+    /**
+     * @constructor
+     * @param {Result} value Constant value.
+     */
+    constructor(value: Result);
+    /**
+     * {@link Evaluable.evaluate}
+     */
+    evaluate(): Result;
+    /**
+     * {@link Evaluable.simplify}
+     */
+    simplify(): Result;
+    /**
+     * {@link Evaluable.serialize}
+     */
+    serialize(): Input;
+    /**
+     * Get the strict representation of the operand.
+     * @return {string}
+     */
+    toString(): string;
+}

package/types/parser/index.d.ts

@@ -1,43 +1,39 @@
-/**
- * Parser module.
- * @module illogical/parser
- */
-import { Evaluable } from '../common/evaluable';
-import { Options } from './options';
-export declare type Input = string | number | boolean | null | Input[] | [string, ...Input[]];
-export declare type ArrayInput = Input[];
-export declare type ExpressionInput = [string, ...Input[]];
-/**
- * Parser of raw expressions into Evaluable expression
- */
-export declare class Parser {
-    private readonly opts;
-    private readonly expectedOperators;
-    /**
-     * @constructor
-     * @param {Options?} options Parser options.
-     */
-    constructor(options?: Partial<Options>);
-    /**
-     * Parser options
-     * @type {Options}
-     */
-    get options(): Options;
-    /**
-     * Parse raw expression into evaluable expression.
-     * @param {ExpressionInput} raw Raw expression.
-     * @return {Evaluable}
-     */
-    parse(raw: ExpressionInput): Evaluable;
-    /**
-     * Parse raw expression based on the expression type.
-     * @param {Input} raw Raw expression.
-     * @return {Evaluable}
-     */
-    private parseRawExp;
-    /**
-     * Get resolved operand
-     * @param raw Raw data
-     */
-    private getOperand;
-}
+import { Evaluable } from '../common/evaluable';
+import { Options } from './options';
+export declare type Input = string | number | boolean | null | Input[] | [string, ...Input[]];
+export declare type ArrayInput = Input[];
+export declare type ExpressionInput = [string, ...Input[]];
+/**
+ * Parser of raw expressions into Evaluable expression
+ */
+export declare class Parser {
+    private readonly opts;
+    private readonly expectedOperators;
+    /**
+     * @constructor
+     * @param {Options?} options Parser options.
+     */
+    constructor(options?: Partial<Options>);
+    /**
+     * Parser options
+     * @type {Options}
+     */
+    get options(): Options;
+    /**
+     * Parse raw expression into evaluable expression.
+     * @param {ExpressionInput} raw Raw expression.
+     * @return {Evaluable}
+     */
+    parse(raw: ExpressionInput): Evaluable;
+    /**
+     * Parse raw expression based on the expression type.
+     * @param {Input} raw Raw expression.
+     * @return {Evaluable}
+     */
+    private parseRawExp;
+    /**
+     * Get resolved operand
+     * @param raw Raw data
+     */
+    private getOperand;
+}