@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/rule/RuleContent.d.ts

@@ -0,0 +1,16 @@
+import { AbstractCondition } from './condition/AbstractCondition';
+import { AbstractOperation } from '../operation/AbstractOperation';
+export declare class RuleContent {
+    private _trigger;
+    private _condition;
+    private _operations;
+    constructor(trigger: AbstractCondition | null, condition: AbstractCondition | null, operations: Array<AbstractOperation> | null);
+    get trigger(): AbstractCondition;
+    set trigger(value: AbstractCondition);
+    get condition(): AbstractCondition;
+    set condition(value: AbstractCondition);
+    get operations(): Array<AbstractOperation> | null;
+    set operations(value: Array<AbstractOperation> | null);
+    toString(): string;
+    private addCondition;
+}

package/dist/xiot/core/spec/typedef/rule/RuleContent.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleContent = void 0;
+const OperationParser_1 = require("./parser/operation/OperationParser");
+const ComplexCondition_1 = require("./condition/ComplexCondition");
+class RuleContent {
+    constructor(trigger, condition, operations) {
+        this._trigger = trigger;
+        this._condition = condition;
+        this._operations = operations;
+    }
+    get trigger() {
+        return this._trigger;
+    }
+    set trigger(value) {
+        this._trigger = value;
+    }
+    get condition() {
+        return this._condition;
+    }
+    set condition(value) {
+        this._condition = value;
+    }
+    get operations() {
+        return this._operations;
+    }
+    set operations(value) {
+        this._operations = value;
+    }
+    toString() {
+        let str = '';
+        if (this.operations !== null && this.operations !== undefined) {
+            if (this.trigger === null || this.trigger === undefined) {
+                str += OperationParser_1.OperationParser.toString(this.operations, false, false);
+            }
+            else {
+                str = `IF ${this.addCondition(str, this.trigger)}`;
+                if (this.condition !== null && this.condition !== undefined) {
+                    str = this.addCondition(str + ' AND ', this.condition);
+                }
+                str += ` THEN\n${OperationParser_1.OperationParser.toString(this.operations)}\nENDIF`;
+            }
+        }
+        return str;
+    }
+    addCondition(b, condition) {
+        if (condition instanceof ComplexCondition_1.ComplexCondition) {
+            b += condition.toString();
+        }
+        else {
+            b += `(${condition.toString()})`;
+        }
+        return b;
+    }
+}
+exports.RuleContent = RuleContent;

package/dist/xiot/core/spec/typedef/rule/RuleType.d.ts

@@ -0,0 +1,7 @@
+export declare enum RuleType {
+    UNDEFINED = 0,
+    MANUAL = 1,
+    TIMER = 2,
+    AUTOMATION = 3,
+    INTERACTION = 4
+}

package/dist/xiot/core/spec/typedef/rule/RuleType.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleType = void 0;
+var RuleType;
+(function (RuleType) {
+    RuleType[RuleType["UNDEFINED"] = 0] = "UNDEFINED";
+    RuleType[RuleType["MANUAL"] = 1] = "MANUAL";
+    RuleType[RuleType["TIMER"] = 2] = "TIMER";
+    RuleType[RuleType["AUTOMATION"] = 3] = "AUTOMATION";
+    RuleType[RuleType["INTERACTION"] = 4] = "INTERACTION";
+})(RuleType || (exports.RuleType = RuleType = {}));

package/dist/xiot/core/spec/typedef/rule/condition/AbstractCondition.d.ts

@@ -0,0 +1,7 @@
+import { PropertyID } from '../../xid/PropertyID';
+import { EventOperation } from '../../operation/EventOperation';
+export declare abstract class AbstractCondition {
+    getPropertyIDList(): Array<PropertyID>;
+    getExternalIDList(): Array<string>;
+    abstract check(externalValues: Map<string, Object>, propertyValues: Map<PropertyID, Object>, event: EventOperation): boolean;
+}

package/dist/xiot/core/spec/typedef/rule/condition/AbstractCondition.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractCondition = void 0;
+class AbstractCondition {
+    getPropertyIDList() {
+        return [];
+    }
+    getExternalIDList() {
+        return [];
+    }
+}
+exports.AbstractCondition = AbstractCondition;

package/dist/xiot/core/spec/typedef/rule/condition/ComplexCondition.d.ts

@@ -0,0 +1,17 @@
+import { AbstractCondition } from './AbstractCondition';
+import { LogicalOperator } from './operator/LogicalOperator';
+import { PropertyID } from '../../xid/PropertyID';
+import { EventOperation } from '../../operation/EventOperation';
+export declare class ComplexCondition extends AbstractCondition {
+    private _conditions;
+    private _operator;
+    constructor(operator: LogicalOperator);
+    get conditions(): Array<AbstractCondition>;
+    set conditions(value: Array<AbstractCondition>);
+    get operator(): LogicalOperator;
+    set operator(value: LogicalOperator);
+    toString(): string;
+    check(externalValues: Map<string, Object>, propertyValues: Map<PropertyID, Object>, event: EventOperation): boolean;
+    getPropertyIDList(): Array<PropertyID>;
+    getExternalIDList(): Array<string>;
+}

package/dist/xiot/core/spec/typedef/rule/condition/ComplexCondition.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComplexCondition = void 0;
+const AbstractCondition_1 = require("./AbstractCondition");
+const Logic_1 = require("./operator/logical/Logic");
+class ComplexCondition extends AbstractCondition_1.AbstractCondition {
+    constructor(operator) {
+        super();
+        this._conditions = [];
+        this._operator = operator;
+    }
+    get conditions() {
+        return this._conditions;
+    }
+    set conditions(value) {
+        this._conditions = value;
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(value) {
+        this._operator = value;
+    }
+    toString() {
+        let str = '(';
+        for (let i = this._conditions.length - 1; i >= 0; i--) {
+            const condition = this._conditions[i];
+            str += condition.toString();
+            if (i !== 0) {
+                str += ' ' + this._operator.toString() + ' ';
+            }
+        }
+        return str + ')';
+    }
+    check(externalValues, propertyValues, event) {
+        const result = new Array();
+        for (const condition of this._conditions) {
+            result.push(condition.check(externalValues, propertyValues, event));
+        }
+        return (0, Logic_1.checkLogic)(this._operator, result);
+    }
+    getPropertyIDList() {
+        const list = new Array();
+        for (const condition of this._conditions) {
+            list.push(...condition.getPropertyIDList());
+        }
+        return list;
+    }
+    getExternalIDList() {
+        const list = new Array();
+        for (const condition of this._conditions) {
+            list.push(...condition.getExternalIDList());
+        }
+        return list;
+    }
+}
+exports.ComplexCondition = ComplexCondition;

package/dist/xiot/core/spec/typedef/rule/condition/EventCondition.d.ts

@@ -0,0 +1,16 @@
+import { AbstractCondition } from './AbstractCondition';
+import { EventID } from '../../xid/EventID';
+import { ArgumentOperation } from '../../operation/ArgumentOperation';
+import { PropertyID } from '../../xid/PropertyID';
+import { EventOperation } from '../../operation/EventOperation';
+export declare class EventCondition extends AbstractCondition {
+    private _eid;
+    private _arguments;
+    constructor(eid: EventID);
+    get eid(): EventID;
+    set eid(value: EventID);
+    get arguments(): Map<Number, ArgumentOperation>;
+    set arguments(value: Map<Number, ArgumentOperation>);
+    check(externalValues: Map<String, Object>, propertyValues: Map<PropertyID, Object>, event: EventOperation): boolean;
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/rule/condition/EventCondition.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventCondition = void 0;
+const AbstractCondition_1 = require("./AbstractCondition");
+class EventCondition extends AbstractCondition_1.AbstractCondition {
+    constructor(eid) {
+        super();
+        this._arguments = new Map();
+        this._eid = eid;
+    }
+    get eid() {
+        return this._eid;
+    }
+    set eid(value) {
+        this._eid = value;
+    }
+    get arguments() {
+        return this._arguments;
+    }
+    set arguments(value) {
+        this._arguments = value;
+    }
+    check(externalValues, propertyValues, event) {
+        if (this._eid.toString() !== event.eid.toString()) {
+            return false;
+        }
+        if (arguments.length > 0) {
+            for (const argument of this._arguments.values()) {
+                const o = event.arguments.get(argument.piid);
+                if (o === null || o === undefined) {
+                    return false;
+                }
+                if (o.values.length !== argument.values.length) {
+                    return false;
+                }
+                for (let i = 0; i < o.values.length; i++) {
+                    if (o.values[i] !== argument.values[i]) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    toString() {
+        let str = this.eid + ' == {';
+        let i = 1;
+        const size = this.arguments.size;
+        this.arguments.forEach((argument) => {
+            str += argument.toString();
+            if (i < size) {
+                str += ', ';
+            }
+            i++;
+        });
+        return str + '}';
+    }
+}
+exports.EventCondition = EventCondition;

package/dist/xiot/core/spec/typedef/rule/condition/ExternalCondition.d.ts

@@ -0,0 +1,19 @@
+import { AbstractCondition } from './AbstractCondition';
+import { ComparisonOperator } from './operator/ComparisonOperator';
+import { PropertyID } from '../../xid/PropertyID';
+import { EventOperation } from '../../operation/EventOperation';
+export declare class ExternalCondition extends AbstractCondition {
+    private _id;
+    private _value;
+    private _operator;
+    constructor(id: string, value: Object, operator: ComparisonOperator);
+    get id(): string;
+    set id(value: string);
+    get value(): Object;
+    set value(value: Object);
+    get operator(): ComparisonOperator;
+    set operator(value: ComparisonOperator);
+    check(externalValues: Map<string, Object>, propertyValues: Map<PropertyID, Object>, event: EventOperation): boolean;
+    getExternalIDList(): Array<string>;
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/rule/condition/ExternalCondition.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalCondition = void 0;
+const AbstractCondition_1 = require("./AbstractCondition");
+class ExternalCondition extends AbstractCondition_1.AbstractCondition {
+    constructor(id, value, operator) {
+        super();
+        this._id = id;
+        this._value = value;
+        this._operator = operator;
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(value) {
+        this._operator = value;
+    }
+    check(externalValues, propertyValues, event) {
+        return false;
+    }
+    getExternalIDList() {
+        return [this._id];
+    }
+    toString() {
+        if ('string' === typeof this._value) {
+            return '@' + this._id + ' ' + this._operator.toString() + ' "' + this._value + '"';
+        }
+        return '@' + this._id + ' ' + this._operator.toString() + ' ' + this._value.toString();
+    }
+}
+exports.ExternalCondition = ExternalCondition;

package/dist/xiot/core/spec/typedef/rule/condition/ExternalType.d.ts

@@ -0,0 +1,5 @@
+export declare enum ExternalType {
+    NOW = "now",
+    TIME = "time",
+    UNDEFINE = "undefine"
+}

package/dist/xiot/core/spec/typedef/rule/condition/ExternalType.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalType = void 0;
+var ExternalType;
+(function (ExternalType) {
+    ExternalType["NOW"] = "now";
+    ExternalType["TIME"] = "time";
+    ExternalType["UNDEFINE"] = "undefine";
+})(ExternalType || (exports.ExternalType = ExternalType = {}));

package/dist/xiot/core/spec/typedef/rule/condition/NowCondition.d.ts

@@ -0,0 +1,5 @@
+import { ExternalCondition } from './ExternalCondition';
+export declare class NowCondition extends ExternalCondition {
+    constructor(cron: string);
+    cron(): string;
+}

package/dist/xiot/core/spec/typedef/rule/condition/NowCondition.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NowCondition = void 0;
+const ExternalCondition_1 = require("./ExternalCondition");
+const ComparisonOperator_1 = require("./operator/ComparisonOperator");
+const ExternalType_1 = require("./ExternalType");
+class NowCondition extends ExternalCondition_1.ExternalCondition {
+    constructor(cron) {
+        super(ExternalType_1.ExternalType.NOW, cron, ComparisonOperator_1.ComparisonOperator.EQUAL);
+    }
+    cron() {
+        return this.value.toString();
+    }
+}
+exports.NowCondition = NowCondition;

package/dist/xiot/core/spec/typedef/rule/condition/PropertyCondition.d.ts

@@ -0,0 +1,19 @@
+import { AbstractCondition } from './AbstractCondition';
+import { PropertyID } from '../../xid/PropertyID';
+import { ComparisonOperator } from './operator/ComparisonOperator';
+import { EventOperation } from '../../operation/EventOperation';
+export declare class PropertyCondition extends AbstractCondition {
+    private _pid;
+    private _value;
+    private _operator;
+    constructor(pid: PropertyID, value: Object, operator: ComparisonOperator);
+    get pid(): PropertyID;
+    set pid(value: PropertyID);
+    get value(): Object;
+    set value(value: Object);
+    get operator(): ComparisonOperator;
+    set operator(value: ComparisonOperator);
+    check(externalValues: Map<String, Object>, propertyValues: Map<PropertyID, Object>, event: EventOperation): boolean;
+    getPropertyIDList(): Array<PropertyID>;
+    toString(): string;
+}

package/dist/xiot/core/spec/typedef/rule/condition/PropertyCondition.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyCondition = void 0;
+const AbstractCondition_1 = require("./AbstractCondition");
+const Comparator_1 = require("./operator/compare/Comparator");
+class PropertyCondition extends AbstractCondition_1.AbstractCondition {
+    constructor(pid, value, operator) {
+        super();
+        this._pid = pid;
+        this._value = value;
+        this._operator = operator;
+    }
+    get pid() {
+        return this._pid;
+    }
+    set pid(value) {
+        this._pid = value;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(value) {
+        this._operator = value;
+    }
+    check(externalValues, propertyValues, event) {
+        const propertyValue = propertyValues.get(this._pid);
+        if (propertyValue !== null && propertyValue !== undefined) {
+            return (0, Comparator_1.checkCompare)(this._operator, propertyValue, this._value);
+        }
+        return false;
+    }
+    getPropertyIDList() {
+        return [this._pid];
+    }
+    toString() {
+        if ('string' === typeof this._value) {
+            return this._pid.toString() + ' ' + this._operator.toString() + ' "' + this._value + '"';
+        }
+        return this._pid.toString() + ' ' + this._operator.toString() + ' ' + this._value.toString();
+    }
+}
+exports.PropertyCondition = PropertyCondition;

package/dist/xiot/core/spec/typedef/rule/condition/TimeCondition.d.ts

@@ -0,0 +1,14 @@
+import { ExternalCondition } from './ExternalCondition';
+import { PropertyID } from '../../xid/PropertyID';
+import { EventOperation } from '../../operation/EventOperation';
+export declare class TimeCondition extends ExternalCondition {
+    static create(start: string, end: string, weekLoops: string): TimeCondition;
+    constructor(value: string);
+    start(): string;
+    end(): string;
+    weekLoops(): string;
+    check(externalValues: Map<string, Object>, propertyValues: Map<PropertyID, Object>, event: EventOperation): boolean;
+    private checkParam;
+    private checkHourMinuteTime;
+    private checkWeekLoops;
+}

package/dist/xiot/core/spec/typedef/rule/condition/TimeCondition.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeCondition = void 0;
+const ExternalCondition_1 = require("./ExternalCondition");
+const ExternalType_1 = require("./ExternalType");
+const ComparisonOperator_1 = require("./operator/ComparisonOperator");
+class TimeCondition extends ExternalCondition_1.ExternalCondition {
+    static create(start, end, weekLoops) {
+        return new TimeCondition(start + ',' + end + ',' + weekLoops);
+    }
+    constructor(value) {
+        super(ExternalType_1.ExternalType.TIME, value, ComparisonOperator_1.ComparisonOperator.EQUAL);
+        if (!this.checkParam(value)) {
+            throw new Error('invalid value, value format like : {HH:mm, HH:mm, weekLoops},' +
+                'weekLoops can be 0123456 or 0235 ..., where 0:Sunday,1:Monday,...,6:Saturday');
+        }
+    }
+    start() {
+        const params = this.value.toString().split(',');
+        return params[0].trim();
+    }
+    end() {
+        const params = this.value.toString().split(',');
+        return params[1].trim();
+    }
+    weekLoops() {
+        const params = this.value.toString().split(',');
+        return params[2].trim();
+    }
+    check(externalValues, propertyValues, event) {
+        const now = new Date();
+        if (this.weekLoops().indexOf(now.getDay().toString()) < 0) {
+            return false;
+        }
+        const hour = now.getHours();
+        const minute = now.getMinutes();
+        const startTimes = this.start().split(':');
+        const endTimes = this.end().split(':');
+        const startHour = parseInt(startTimes[0], 10);
+        const endHour = parseInt(endTimes[0], 10);
+        const startMinute = parseInt(startTimes[1], 10);
+        const endMinute = parseInt(endTimes[1], 10);
+        return hour >= startHour && (hour !== startHour || minute >= startMinute)
+            && hour <= endHour && (hour !== endHour || minute <= endMinute);
+    }
+    checkParam(value) {
+        const params = value.split(',');
+        if (params.length !== 3) {
+            return false;
+        }
+        const start = params[0].trim();
+        const end = params[1].trim();
+        const weekLoops = params[2].trim();
+        return this.checkHourMinuteTime(start) && this.checkHourMinuteTime(end) && this.checkWeekLoops(weekLoops);
+    }
+    checkHourMinuteTime(hourMinuteTime) {
+        const hour = parseInt(hourMinuteTime.substring(0, 1), 10);
+        const minute = parseInt(hourMinuteTime.substring(3, 4), 10);
+        return hour >= 0 && hour < 24
+            && minute >= 0 && minute < 60
+            && hourMinuteTime.charAt(2) === ':';
+    }
+    checkWeekLoops(weekLoops) {
+        // weekLoops 不重复的7位以下的数字，数字为0-6,最多7位数，最少1位数
+        const tmp = new Uint8Array(7);
+        const zeroCharCode = '0'.charCodeAt(0);
+        for (let i = 0; i < weekLoops.length; i++) {
+            if (weekLoops.charAt(i) < '0' || weekLoops.charAt(i) >= '7') {
+                return false;
+            }
+            tmp[weekLoops.charCodeAt(i) - zeroCharCode] += 1;
+        }
+        let count = 0;
+        for (let i = 0; i < 7; i++) {
+            if (tmp[i] > 1) {
+                return false;
+            }
+            if (tmp[i] === 1) {
+                count++;
+            }
+        }
+        return count <= 7 && count >= 1;
+    }
+}
+exports.TimeCondition = TimeCondition;

package/dist/xiot/core/spec/typedef/rule/condition/operator/ComparisonOperator.d.ts

@@ -0,0 +1,10 @@
+export declare enum ComparisonOperator {
+    UNDEFINED = "?",
+    EQUAL = "==",
+    GREATER = ">",
+    LESS = "<",
+    GREATER_OR_EQUAL = ">=",
+    LESS_OR_EQUAL = "<=",
+    NOT_EQUAL = "!="
+}
+export declare function getComparisonOperator(value: String): ComparisonOperator;

package/dist/xiot/core/spec/typedef/rule/condition/operator/ComparisonOperator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComparisonOperator = void 0;
+exports.getComparisonOperator = getComparisonOperator;
+var ComparisonOperator;
+(function (ComparisonOperator) {
+    ComparisonOperator["UNDEFINED"] = "?";
+    ComparisonOperator["EQUAL"] = "==";
+    ComparisonOperator["GREATER"] = ">";
+    ComparisonOperator["LESS"] = "<";
+    ComparisonOperator["GREATER_OR_EQUAL"] = ">=";
+    ComparisonOperator["LESS_OR_EQUAL"] = "<=";
+    ComparisonOperator["NOT_EQUAL"] = "!=";
+})(ComparisonOperator || (exports.ComparisonOperator = ComparisonOperator = {}));
+function getComparisonOperator(value) {
+    switch (value) {
+        case ComparisonOperator.EQUAL:
+            return ComparisonOperator.EQUAL;
+        case ComparisonOperator.GREATER:
+            return ComparisonOperator.GREATER;
+        case ComparisonOperator.LESS:
+            return ComparisonOperator.LESS;
+        case ComparisonOperator.GREATER_OR_EQUAL:
+            return ComparisonOperator.GREATER_OR_EQUAL;
+        case ComparisonOperator.LESS_OR_EQUAL:
+            return ComparisonOperator.LESS_OR_EQUAL;
+        case ComparisonOperator.NOT_EQUAL:
+            return ComparisonOperator.NOT_EQUAL;
+        default:
+            return ComparisonOperator.UNDEFINED;
+    }
+}

package/dist/xiot/core/spec/typedef/rule/condition/operator/LogicalOperator.d.ts

@@ -0,0 +1,6 @@
+export declare enum LogicalOperator {
+    UNDEFINED = "?",
+    AND = "&&",
+    OR = "||"
+}
+export declare function getLogicalOperator(value: String): LogicalOperator;

package/dist/xiot/core/spec/typedef/rule/condition/operator/LogicalOperator.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicalOperator = void 0;
+exports.getLogicalOperator = getLogicalOperator;
+var LogicalOperator;
+(function (LogicalOperator) {
+    LogicalOperator["UNDEFINED"] = "?";
+    LogicalOperator["AND"] = "&&";
+    LogicalOperator["OR"] = "||";
+})(LogicalOperator || (exports.LogicalOperator = LogicalOperator = {}));
+function getLogicalOperator(value) {
+    switch (value) {
+        case LogicalOperator.UNDEFINED:
+            return LogicalOperator.UNDEFINED;
+        case LogicalOperator.AND:
+            return LogicalOperator.AND;
+        case LogicalOperator.OR:
+            return LogicalOperator.OR;
+        default:
+            return LogicalOperator.UNDEFINED;
+    }
+}

package/dist/xiot/core/spec/typedef/rule/condition/operator/compare/Comparator.d.ts

@@ -0,0 +1,2 @@
+import { ComparisonOperator } from '../ComparisonOperator';
+export declare function checkCompare(operator: ComparisonOperator, left: Object, right: Object): boolean;

package/dist/xiot/core/spec/typedef/rule/condition/operator/compare/Comparator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCompare = checkCompare;
+const Compare_1 = require("./Compare");
+const ComparisonOperator_1 = require("../ComparisonOperator");
+const compares = new Map([
+    [ComparisonOperator_1.ComparisonOperator.EQUAL, new Compare_1.CompareEqual()],
+    [ComparisonOperator_1.ComparisonOperator.NOT_EQUAL, new Compare_1.CompareNotEqual()],
+    [ComparisonOperator_1.ComparisonOperator.LESS, new Compare_1.CompareLess()],
+    [ComparisonOperator_1.ComparisonOperator.LESS_OR_EQUAL, new Compare_1.CompareLessOrEqual()],
+    [ComparisonOperator_1.ComparisonOperator.GREATER, new Compare_1.CompareGreater()],
+    [ComparisonOperator_1.ComparisonOperator.GREATER_OR_EQUAL, new Compare_1.CompareGreaterOrEqual()]
+]);
+function checkCompare(operator, left, right) {
+    const compare = compares.get(operator);
+    if (compare === undefined || compare === null) {
+        return false;
+    }
+    return compare.check(left, right);
+}