@defra/forms-model 3.0.2

package/dist/module/conditions/index.js

@@ -0,0 +1,140 @@
+"use strict";
+
+exports.__esModule = true;
+Object.defineProperty(exports, "Condition", {
+  enumerable: true,
+  get: function () {
+    return _condition.Condition;
+  }
+});
+Object.defineProperty(exports, "ConditionField", {
+  enumerable: true,
+  get: function () {
+    return _conditionField.ConditionField;
+  }
+});
+Object.defineProperty(exports, "ConditionGroup", {
+  enumerable: true,
+  get: function () {
+    return _conditionGroup.ConditionGroup;
+  }
+});
+Object.defineProperty(exports, "ConditionGroupDef", {
+  enumerable: true,
+  get: function () {
+    return _conditionGroupDef.ConditionGroupDef;
+  }
+});
+Object.defineProperty(exports, "ConditionRef", {
+  enumerable: true,
+  get: function () {
+    return _conditionRef.ConditionRef;
+  }
+});
+Object.defineProperty(exports, "ConditionValue", {
+  enumerable: true,
+  get: function () {
+    return _conditionValues.ConditionValue;
+  }
+});
+Object.defineProperty(exports, "ConditionsModel", {
+  enumerable: true,
+  get: function () {
+    return _conditionModel.ConditionsModel;
+  }
+});
+Object.defineProperty(exports, "Coordinator", {
+  enumerable: true,
+  get: function () {
+    return _types.Coordinator;
+  }
+});
+Object.defineProperty(exports, "DateDirections", {
+  enumerable: true,
+  get: function () {
+    return _conditionValues.DateDirections;
+  }
+});
+Object.defineProperty(exports, "RelativeTimeValue", {
+  enumerable: true,
+  get: function () {
+    return _conditionValues.RelativeTimeValue;
+  }
+});
+Object.defineProperty(exports, "absoluteDateOrTimeOperatorNames", {
+  enumerable: true,
+  get: function () {
+    return _conditionOperators.absoluteDateOrTimeOperatorNames;
+  }
+});
+Object.defineProperty(exports, "conditionValueFrom", {
+  enumerable: true,
+  get: function () {
+    return _conditionValues.conditionValueFrom;
+  }
+});
+Object.defineProperty(exports, "dateTimeUnits", {
+  enumerable: true,
+  get: function () {
+    return _conditionValues.dateTimeUnits;
+  }
+});
+Object.defineProperty(exports, "dateUnits", {
+  enumerable: true,
+  get: function () {
+    return _conditionValues.dateUnits;
+  }
+});
+Object.defineProperty(exports, "getExpression", {
+  enumerable: true,
+  get: function () {
+    return _conditionOperators.getExpression;
+  }
+});
+Object.defineProperty(exports, "getOperatorConfig", {
+  enumerable: true,
+  get: function () {
+    return _conditionOperators.getOperatorConfig;
+  }
+});
+Object.defineProperty(exports, "getOperatorNames", {
+  enumerable: true,
+  get: function () {
+    return _conditionOperators.getOperatorNames;
+  }
+});
+Object.defineProperty(exports, "relativeDateOrTimeOperatorNames", {
+  enumerable: true,
+  get: function () {
+    return _conditionOperators.relativeDateOrTimeOperatorNames;
+  }
+});
+Object.defineProperty(exports, "timeUnits", {
+  enumerable: true,
+  get: function () {
+    return _conditionValues.timeUnits;
+  }
+});
+Object.defineProperty(exports, "toExpression", {
+  enumerable: true,
+  get: function () {
+    return _helpers.toExpression;
+  }
+});
+Object.defineProperty(exports, "toPresentationString", {
+  enumerable: true,
+  get: function () {
+    return _helpers.toPresentationString;
+  }
+});
+var _conditionOperators = require("./condition-operators");
+var _conditionValues = require("./condition-values");
+var _conditionField = require("./condition-field");
+var _condition = require("./condition");
+var _conditionRef = require("./condition-ref");
+var _conditionGroup = require("./condition-group");
+var _conditionModel = require("./condition-model");
+var _conditionGroupDef = require("./condition-group-def");
+var _helpers = require("./helpers");
+var _types = require("./types");
+//# sourceMappingURL=index.js.map

package/dist/module/conditions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_conditionOperators","require","_conditionValues","_conditionField","_condition","_conditionRef","_conditionGroup","_conditionModel","_conditionGroupDef","_helpers","_types"],"sources":["../../../src/conditions/index.ts"],"sourcesContent":["export {\n  getExpression,\n  getOperatorConfig,\n  getOperatorNames,\n  absoluteDateOrTimeOperatorNames,\n  relativeDateOrTimeOperatorNames\n} from './condition-operators'\n\nexport {\n  timeUnits,\n  dateUnits,\n  dateTimeUnits,\n  ConditionValue,\n  DateDirections,\n  RelativeTimeValue,\n  conditionValueFrom\n} from './condition-values'\n\nexport { ConditionField } from './condition-field'\nexport { Condition } from './condition'\nexport { ConditionRef } from './condition-ref'\nexport { ConditionGroup } from './condition-group'\nexport { ConditionsModel } from './condition-model'\nexport { ConditionGroupDef } from './condition-group-def'\nexport { toExpression, toPresentationString } from './helpers'\n\nexport { Coordinator } from './types'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,mBAAA,GAAAC,OAAA;AAQA,IAAAC,gBAAA,GAAAD,OAAA;AAUA,IAAAE,eAAA,GAAAF,OAAA;AACA,IAAAG,UAAA,GAAAH,OAAA;AACA,IAAAI,aAAA,GAAAJ,OAAA;AACA,IAAAK,eAAA,GAAAL,OAAA;AACA,IAAAM,eAAA,GAAAN,OAAA;AACA,IAAAO,kBAAA,GAAAP,OAAA;AACA,IAAAQ,QAAA,GAAAR,OAAA;AAEA,IAAAS,MAAA,GAAAT,OAAA"}

package/dist/module/conditions/inline-condition-model.d.ts

@@ -0,0 +1,86 @@
+export declare const coordinators: {
+    AND: string;
+    OR: string;
+};
+export declare class ConditionsModel {
+    #private;
+    constructor();
+    clone(): ConditionsModel;
+    clear(): this;
+    set name(name: any);
+    get name(): any;
+    add(condition: any): this;
+    replace(index: any, condition: any): this;
+    remove(indexes: any): this;
+    addGroups(groupDefs: any): this;
+    splitGroup(index: any): this;
+    moveEarlier(index: any): this;
+    moveLater(index: any): this;
+    switchCoordinators(): void;
+    get asPerUserGroupings(): any[];
+    get hasConditions(): boolean;
+    get lastIndex(): number;
+    toPresentationString(): any;
+    toExpression(): any;
+    _applyGroups(userGroupedConditions: any): any;
+    _group(conditions: any, groupDefs: any): any;
+    _ungroup(conditions: any, splitIndex: any): any;
+    _autoGroupDefs(conditions: any): GroupDef[];
+    toJSON(): {
+        name: any;
+        conditions: any;
+    };
+    static from(obj: any): ConditionsModel;
+}
+export declare class GroupDef {
+    first: any;
+    last: any;
+    constructor(first: any, last: any);
+    contains(index: any): boolean;
+    startsWith(index: any): boolean;
+    applyTo(conditions: any): any[];
+}
+export declare function toPresentationString(condition: any): string;
+export declare function toExpression(condition: any): string;
+export declare class Field {
+    name: any;
+    type: any;
+    display: any;
+    constructor(name: any, type: any, display: any);
+    static from(obj: any): Field;
+}
+declare class AbstractCondition {
+    coordinator: any;
+    constructor(coordinator: any);
+    coordinatorString(): string;
+    getCoordinator(): any;
+    setCoordinator(coordinator: any): void;
+    isGroup(): boolean;
+    getGroupedConditions(): this[];
+    _asFirstCondition(): void;
+    asFirstCondition(): void;
+    clone(): void;
+    conditionString(): void;
+    conditionExpression(): void;
+}
+export declare class Condition extends AbstractCondition {
+    field: any;
+    operator: any;
+    value: any;
+    constructor(field: any, operator: any, value: any, coordinator: any);
+    asFirstCondition(): this;
+    conditionString(): string;
+    conditionExpression(): any;
+    clone(): Condition;
+}
+export declare class ConditionRef extends AbstractCondition {
+    conditionName: any;
+    conditionDisplayName: any;
+    constructor(conditionName: any, conditionDisplayName: any, coordinator: any);
+    asFirstCondition(): this;
+    conditionString(): string;
+    conditionExpression(): any;
+    clone(): ConditionRef;
+}
+export {};
+//# sourceMappingURL=inline-condition-model.d.ts.map

package/dist/module/conditions/inline-condition-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-condition-model.d.ts","sourceRoot":"","sources":["../../../src/conditions/inline-condition-model.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;CAGxB,CAAA;AAED,qBAAa,eAAe;;;IAU1B,KAAK;IAYL,KAAK;IAOL,IAAI,IAAI,CAAC,IAAI,KAAA,EAEZ;IAED,IAAI,IAAI,QAEP;IAED,GAAG,CAAC,SAAS,KAAA;IAYb,OAAO,CAAC,KAAK,KAAA,EAAE,SAAS,KAAA;IAgBxB,MAAM,CAAC,OAAO,KAAA;IAWd,SAAS,CAAC,SAAS,KAAA;IASnB,UAAU,CAAC,KAAK,KAAA;IAShB,WAAW,CAAC,KAAK,KAAA;IAejB,SAAS,CAAC,KAAK,KAAA;IAef,kBAAkB;IAOlB,IAAI,kBAAkB,UAErB;IAED,IAAI,aAAa,YAEhB;IAED,IAAI,SAAS,WAEZ;IAED,oBAAoB;IAMpB,YAAY;IAMZ,YAAY,CAAC,qBAAqB,KAAA;IAiBlC,MAAM,CAAC,UAAU,KAAA,EAAE,SAAS,KAAA;IAe5B,QAAQ,CAAC,UAAU,KAAA,EAAE,UAAU,KAAA;IAa/B,cAAc,CAAC,UAAU,KAAA;IA8BzB,MAAM;;;;IASN,MAAM,CAAC,IAAI,CAAC,GAAG,KAAA;CAchB;AAuBD,qBAAa,QAAQ;IACnB,KAAK,MAAA;IACL,IAAI,MAAA;gBAEQ,KAAK,KAAA,EAAE,IAAI,KAAA;IAUvB,QAAQ,CAAC,KAAK,KAAA;IAId,UAAU,CAAC,KAAK,KAAA;IAIhB,OAAO,CAAC,UAAU,KAAA;CAGnB;AA4DD,wBAAgB,oBAAoB,CAAC,SAAS,KAAA,UAE7C;AAED,wBAAgB,YAAY,CAAC,SAAS,KAAA,UAErC;AAED,qBAAa,KAAK;IAChB,IAAI,MAAA;IACJ,IAAI,MAAA;IACJ,OAAO,MAAA;gBAEK,IAAI,KAAA,EAAE,IAAI,KAAA,EAAE,OAAO,KAAA;IAe/B,MAAM,CAAC,IAAI,CAAC,GAAG,KAAA;CAGhB;AAED,cAAM,iBAAiB;IACrB,WAAW,MAAA;gBAEC,WAAW,KAAA;IAOvB,iBAAiB;IAIjB,cAAc;IAId,cAAc,CAAC,WAAW,KAAA;IAI1B,OAAO;IAIP,oBAAoB;IAIpB,iBAAiB;IAIjB,gBAAgB;IAMhB,KAAK;IAML,eAAe;IAMf,mBAAmB;CAKpB;AAED,qBAAa,SAAU,SAAQ,iBAAiB;IAC9C,KAAK,MAAA;IACL,QAAQ,MAAA;IACR,KAAK,MAAA;gBAEO,KAAK,KAAA,EAAE,QAAQ,KAAA,EAAE,KAAK,KAAA,EAAE,WAAW,KAAA;IAgB/C,gBAAgB;IAKhB,eAAe;IAMf,mBAAmB;IASnB,KAAK;CAQN;AAED,qBAAa,YAAa,SAAQ,iBAAiB;IACjD,aAAa,MAAA;IACb,oBAAoB,MAAA;gBAER,aAAa,KAAA,EAAE,oBAAoB,KAAA,EAAE,WAAW,KAAA;IAY5D,gBAAgB;IAKhB,eAAe;IAIf,mBAAmB;IAInB,KAAK;CAON"}

package/dist/module/conditions/inline-condition-model.js

@@ -0,0 +1,384 @@
+"use strict";
+
+exports.__esModule = true;
+exports.coordinators = exports.GroupDef = exports.Field = exports.ConditionsModel = exports.ConditionRef = exports.Condition = void 0;
+exports.toExpression = toExpression;
+exports.toPresentationString = toPresentationString;
+var _componentTypes = require("../components/component-types");
+var _inlineConditionOperators = require("./inline-condition-operators");
+var _inlineConditionValues = require("./inline-condition-values");
+const coordinators = exports.coordinators = {
+  AND: 'and',
+  OR: 'or'
+};
+class ConditionsModel {
+  #groupedConditions;
+  #userGroupedConditions;
+  #conditionName;
+  constructor() {
+    this.#groupedConditions = [];
+    this.#userGroupedConditions = [];
+  }
+  clone() {
+    const toReturn = new ConditionsModel();
+    toReturn.#groupedConditions = this.#groupedConditions.map(it => it.clone());
+    toReturn.#userGroupedConditions = this.#userGroupedConditions.map(it => it.clone());
+    toReturn.#conditionName = this.#conditionName;
+    return toReturn;
+  }
+  clear() {
+    this.#userGroupedConditions = [];
+    this.#groupedConditions = [];
+    this.#conditionName = undefined;
+    return this;
+  }
+  set name(name) {
+    this.#conditionName = name;
+  }
+  get name() {
+    return this.#conditionName;
+  }
+  add(condition) {
+    const coordinatorExpected = this.#userGroupedConditions.length !== 0;
+    if (condition.getCoordinator() && !coordinatorExpected) {
+      throw Error('No coordinator allowed on the first condition');
+    } else if (!condition.getCoordinator() && coordinatorExpected) {
+      throw Error('Coordinator must be present on subsequent conditions');
+    }
+    this.#userGroupedConditions.push(condition);
+    this.#groupedConditions = this._applyGroups(this.#userGroupedConditions);
+    return this;
+  }
+  replace(index, condition) {
+    const coordinatorExpected = index !== 0;
+    if (condition.getCoordinator() && !coordinatorExpected) {
+      throw Error('No coordinator allowed on the first condition');
+    } else if (!condition.getCoordinator() && coordinatorExpected) {
+      throw Error('Coordinator must be present on subsequent conditions');
+    } else if (index >= this.#userGroupedConditions.length) {
+      throw Error(`Cannot replace condition ${index} as no such condition exists`);
+    }
+    this.#userGroupedConditions.splice(index, 1, condition);
+    this.#groupedConditions = this._applyGroups(this.#userGroupedConditions);
+    return this;
+  }
+  remove(indexes) {
+    this.#userGroupedConditions = this.#userGroupedConditions.filter((_condition, index) => !indexes.includes(index)).map((condition, index) => index === 0 ? condition.asFirstCondition() : condition);
+    this.#groupedConditions = this._applyGroups(this.#userGroupedConditions);
+    return this;
+  }
+  addGroups(groupDefs) {
+    this.#userGroupedConditions = this._group(this.#userGroupedConditions, groupDefs);
+    this.#groupedConditions = this._applyGroups(this.#userGroupedConditions);
+    return this;
+  }
+  splitGroup(index) {
+    this.#userGroupedConditions = this._ungroup(this.#userGroupedConditions, index);
+    this.#groupedConditions = this._applyGroups(this.#userGroupedConditions);
+    return this;
+  }
+  moveEarlier(index) {
+    if (index > 0 && index < this.#userGroupedConditions.length) {
+      this.#userGroupedConditions.splice(index - 1, 0, this.#userGroupedConditions.splice(index, 1)[0]);
+      if (index === 1) {
+        this.switchCoordinators();
+      }
+      this.#groupedConditions = this._applyGroups(this.#userGroupedConditions);
+    }
+    return this;
+  }
+  moveLater(index) {
+    if (index >= 0 && index < this.#userGroupedConditions.length - 1) {
+      this.#userGroupedConditions.splice(index + 1, 0, this.#userGroupedConditions.splice(index, 1)[0]);
+      if (index === 0) {
+        this.switchCoordinators();
+      }
+      this.#groupedConditions = this._applyGroups(this.#userGroupedConditions);
+    }
+    return this;
+  }
+  switchCoordinators() {
+    this.#userGroupedConditions[1].setCoordinator(this.#userGroupedConditions[0].getCoordinator());
+    this.#userGroupedConditions[0].setCoordinator(undefined);
+  }
+  get asPerUserGroupings() {
+    return [...this.#userGroupedConditions];
+  }
+  get hasConditions() {
+    return this.#userGroupedConditions.length > 0;
+  }
+  get lastIndex() {
+    return this.#userGroupedConditions.length - 1;
+  }
+  toPresentationString() {
+    return this.#groupedConditions.map(condition => toPresentationString(condition)).join(' ');
+  }
+  toExpression() {
+    return this.#groupedConditions.map(condition => toExpression(condition)).join(' ');
+  }
+  _applyGroups(userGroupedConditions) {
+    const correctedUserGroups = userGroupedConditions.map(condition => condition instanceof ConditionGroup && condition.conditions.length > 2 ? new ConditionGroup(this._group(condition.conditions, this._autoGroupDefs(condition.conditions))) : condition);
+    return this._group(correctedUserGroups, this._autoGroupDefs(correctedUserGroups));
+  }
+  _group(conditions, groupDefs) {
+    return conditions.reduce((groups, condition, index, conditions) => {
+      const groupDef = groupDefs.find(groupDef => groupDef.contains(index));
+      if (groupDef) {
+        if (groupDef.startsWith(index)) {
+          const groupConditions = groupDef.applyTo(conditions);
+          groups.push(new ConditionGroup(groupConditions));
+        }
+      } else {
+        groups.push(condition);
+      }
+      return groups;
+    }, []);
+  }
+  _ungroup(conditions, splitIndex) {
+    if (conditions[splitIndex].isGroup()) {
+      const copy = [...conditions];
+      copy.splice(splitIndex, 1, ...conditions[splitIndex].getGroupedConditions());
+      return copy;
+    }
+    return conditions;
+  }
+  _autoGroupDefs(conditions) {
+    const orPositions = [];
+    conditions.forEach((condition, index) => {
+      if (condition.getCoordinator() === coordinators.OR) {
+        orPositions.push(index);
+      }
+    });
+    const hasAnd = !!conditions.find(condition => condition.getCoordinator() === coordinators.AND);
+    const hasOr = orPositions.length > 0;
+    if (hasAnd && hasOr) {
+      let start = 0;
+      const groupDefs = [];
+      orPositions.forEach((position, index) => {
+        if (start < position - 1) {
+          groupDefs.push(new GroupDef(start, position - 1));
+        }
+        const thisIsTheLastOr = orPositions.length === index + 1;
+        const thereAreMoreConditions = conditions.length - 1 > position;
+        if (thisIsTheLastOr && thereAreMoreConditions) {
+          groupDefs.push(new GroupDef(position, conditions.length - 1));
+        }
+        start = position;
+      });
+      return groupDefs;
+    }
+    return [];
+  }
+  toJSON() {
+    const name = this.#conditionName;
+    const conditions = this.#userGroupedConditions;
+    return {
+      name,
+      conditions: conditions.map(it => it.clone())
+    };
+  }
+  static from(obj) {
+    if (obj instanceof ConditionsModel) {
+      return obj;
+    }
+    const toReturn = new ConditionsModel();
+    toReturn.#conditionName = obj.name;
+    toReturn.#userGroupedConditions = obj.conditions.map(it => conditionFrom(it));
+    toReturn.#groupedConditions = toReturn._applyGroups(toReturn.#userGroupedConditions);
+    return toReturn;
+  }
+}
+exports.ConditionsModel = ConditionsModel;
+function conditionFrom(it) {
+  if (it.conditions) {
+    return new ConditionGroup(it.conditions.map(condition => conditionFrom(condition)));
+  }
+  if (it.conditionName) {
+    return new ConditionRef(it.conditionName, it.conditionDisplayName, it.coordinator);
+  }
+  return new Condition(Field.from(it.field), it.operator, (0, _inlineConditionValues.valueFrom)(it.value), it.coordinator);
+}
+class GroupDef {
+  constructor(first, last) {
+    if (typeof first !== 'number' || typeof last !== 'number') {
+      throw Error(`Cannot construct a group from ${first} and ${last}`);
+    } else if (first >= last) {
+      throw Error(`Last (${last}) must be greater than first (${first})`);
+    }
+    this.first = first;
+    this.last = last;
+  }
+  contains(index) {
+    return this.first <= index && this.last >= index;
+  }
+  startsWith(index) {
+    return this.first === index;
+  }
+  applyTo(conditions) {
+    return [...conditions].splice(this.first, this.last - this.first + 1);
+  }
+}
+exports.GroupDef = GroupDef;
+class ConditionGroup {
+  constructor(conditions) {
+    if (!Array.isArray(conditions) || conditions.length < 2) {
+      throw Error('Cannot construct a condition group from a single condition');
+    }
+    this.conditions = conditions;
+  }
+  coordinatorString() {
+    return this.conditions[0].coordinatorString();
+  }
+  conditionString() {
+    const copy = [...this.conditions];
+    copy.splice(0, 1);
+    return `(${this.conditions[0].conditionString()} ${copy.map(condition => toPresentationString(condition)).join(' ')})`;
+  }
+  conditionExpression() {
+    const copy = [...this.conditions];
+    copy.splice(0, 1);
+    return `(${this.conditions[0].conditionExpression()} ${copy.map(condition => toExpression(condition)).join(' ')})`;
+  }
+  asFirstCondition() {
+    this.conditions[0].asFirstCondition();
+    return this;
+  }
+  getCoordinator() {
+    return this.conditions[0].getCoordinator();
+  }
+  setCoordinator(coordinator) {
+    this.conditions[0].setCoordinator(coordinator);
+  }
+  isGroup() {
+    return true;
+  }
+  getGroupedConditions() {
+    return this.conditions.map(condition => condition.clone());
+  }
+  clone() {
+    return new ConditionGroup(this.conditions.map(condition => condition.clone()));
+  }
+}
+function toPresentationString(condition) {
+  return `${condition.coordinatorString()}${condition.conditionString()}`;
+}
+function toExpression(condition) {
+  return `${condition.coordinatorString()}${condition.conditionExpression()}`;
+}
+class Field {
+  constructor(name, type, display) {
+    if (!name || typeof name !== 'string') {
+      throw Error(`name ${name} is not valid`);
+    }
+    if (!_componentTypes.ComponentTypes.find(componentType => componentType.name === type)) {
+      throw Error(`type ${type} is not valid`);
+    }
+    if (!display || typeof display !== 'string') {
+      throw Error(`display ${display} is not valid`);
+    }
+    this.name = name;
+    this.type = type;
+    this.display = display;
+  }
+  static from(obj) {
+    return new Field(obj.name, obj.type, obj.display);
+  }
+}
+exports.Field = Field;
+class AbstractCondition {
+  constructor(coordinator) {
+    if (coordinator && !Object.values(coordinators).includes(coordinator)) {
+      throw Error(`coordinator ${coordinator} is not a valid coordinator`);
+    }
+    this.coordinator = coordinator;
+  }
+  coordinatorString() {
+    return this.coordinator ? `${this.coordinator} ` : '';
+  }
+  getCoordinator() {
+    return this.coordinator;
+  }
+  setCoordinator(coordinator) {
+    this.coordinator = coordinator;
+  }
+  isGroup() {
+    return false;
+  }
+  getGroupedConditions() {
+    return [this];
+  }
+  _asFirstCondition() {
+    delete this.coordinator;
+  }
+  asFirstCondition() {
+    throw Error('Implement on the subclass (Why do we have to have this method here at all?!)');
+  }
+  clone() {
+    throw Error('Implement on the subclass (Why do we have to have this method here at all?!)');
+  }
+  conditionString() {
+    throw Error('Implement on the subclass (Why do we have to have this method here at all?!)');
+  }
+  conditionExpression() {
+    throw Error('Implement on the subclass (Why do we have to have this method here at all?!)');
+  }
+}
+class Condition extends AbstractCondition {
+  constructor(field, operator, value, coordinator) {
+    super(coordinator);
+    if (!(field instanceof Field)) {
+      throw Error(`field ${field} is not a valid Field object`);
+    }
+    if (typeof operator !== 'string') {
+      throw Error(`operator ${operator} is not a valid operator`);
+    }
+    if (!(value instanceof _inlineConditionValues.AbstractConditionValue)) {
+      throw Error(`value ${value} is not a valid value type`);
+    }
+    this.field = field;
+    this.operator = operator;
+    this.value = value;
+  }
+  asFirstCondition() {
+    this._asFirstCondition();
+    return this;
+  }
+  conditionString() {
+    return `'${this.field.display}' ${this.operator} '${this.value.toPresentationString()}'`;
+  }
+  conditionExpression() {
+    return (0, _inlineConditionOperators.getExpression)(this.field.type, this.field.name, this.operator, this.value);
+  }
+  clone() {
+    return new Condition(Field.from(this.field), this.operator, this.value.clone(), this.coordinator);
+  }
+}
+exports.Condition = Condition;
+class ConditionRef extends AbstractCondition {
+  constructor(conditionName, conditionDisplayName, coordinator) {
+    super(coordinator);
+    if (typeof conditionName !== 'string') {
+      throw Error(`condition name ${conditionName} is not valid`);
+    }
+    if (typeof conditionDisplayName !== 'string') {
+      throw Error(`condition display name ${conditionDisplayName} is not valid`);
+    }
+    this.conditionName = conditionName;
+    this.conditionDisplayName = conditionDisplayName;
+  }
+  asFirstCondition() {
+    this._asFirstCondition();
+    return this;
+  }
+  conditionString() {
+    return `'${this.conditionDisplayName}'`;
+  }
+  conditionExpression() {
+    return this.conditionName;
+  }
+  clone() {
+    return new ConditionRef(this.conditionName, this.conditionDisplayName, this.coordinator);
+  }
+}
+exports.ConditionRef = ConditionRef;
+//# sourceMappingURL=inline-condition-model.js.map