@defra/forms-model 3.0.2

package/dist/browser/conditions/index.js

@@ -0,0 +1,144 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./condition-operators", "./condition-values", "./condition-field", "./condition", "./condition-ref", "./condition-group", "./condition-model", "./condition-group-def", "./helpers", "./types"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./condition-operators"), require("./condition-values"), require("./condition-field"), require("./condition"), require("./condition-ref"), require("./condition-group"), require("./condition-model"), require("./condition-group-def"), require("./helpers"), require("./types"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.conditionOperators, global.conditionValues, global.conditionField, global.condition, global.conditionRef, global.conditionGroup, global.conditionModel, global.conditionGroupDef, global.helpers, global.types);
+    global.index = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _conditionOperators, _conditionValues, _conditionField, _condition, _conditionRef, _conditionGroup, _conditionModel, _conditionGroupDef, _helpers, _types) {
+  "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;
+    }
+  });
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"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":""}

package/dist/browser/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/browser/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/browser/conditions/inline-condition-model.js

@@ -0,0 +1,418 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "../components/component-types", "./inline-condition-operators", "./inline-condition-values"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("../components/component-types"), require("./inline-condition-operators"), require("./inline-condition-values"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.componentTypes, global.inlineConditionOperators, global.inlineConditionValues);
+    global.inlineConditionModel = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _componentTypes, _inlineConditionOperators, _inlineConditionValues) {
+  "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;
+  function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+  function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+  function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+  function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+  function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+  function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+  function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+  function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+  const coordinators = _exports.coordinators = {
+    AND: 'and',
+    OR: 'or'
+  };
+  var _groupedConditions = /*#__PURE__*/new WeakMap();
+  var _userGroupedConditions = /*#__PURE__*/new WeakMap();
+  var _conditionName = /*#__PURE__*/new WeakMap();
+  class ConditionsModel {
+    constructor() {
+      _classPrivateFieldInitSpec(this, _groupedConditions, void 0);
+      _classPrivateFieldInitSpec(this, _userGroupedConditions, void 0);
+      _classPrivateFieldInitSpec(this, _conditionName, void 0);
+      _classPrivateFieldSet(_groupedConditions, this, []);
+      _classPrivateFieldSet(_userGroupedConditions, this, []);
+    }
+    clone() {
+      const toReturn = new ConditionsModel();
+      _classPrivateFieldSet(_groupedConditions, toReturn, _classPrivateFieldGet(_groupedConditions, this).map(it => it.clone()));
+      _classPrivateFieldSet(_userGroupedConditions, toReturn, _classPrivateFieldGet(_userGroupedConditions, this).map(it => it.clone()));
+      _classPrivateFieldSet(_conditionName, toReturn, _classPrivateFieldGet(_conditionName, this));
+      return toReturn;
+    }
+    clear() {
+      _classPrivateFieldSet(_userGroupedConditions, this, []);
+      _classPrivateFieldSet(_groupedConditions, this, []);
+      _classPrivateFieldSet(_conditionName, this, undefined);
+      return this;
+    }
+    set name(name) {
+      _classPrivateFieldSet(_conditionName, this, name);
+    }
+    get name() {
+      return _classPrivateFieldGet(_conditionName, this);
+    }
+    add(condition) {
+      const coordinatorExpected = _classPrivateFieldGet(_userGroupedConditions, this).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');
+      }
+      _classPrivateFieldGet(_userGroupedConditions, this).push(condition);
+      _classPrivateFieldSet(_groupedConditions, this, this._applyGroups(_classPrivateFieldGet(_userGroupedConditions, this)));
+      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 >= _classPrivateFieldGet(_userGroupedConditions, this).length) {
+        throw Error(`Cannot replace condition ${index} as no such condition exists`);
+      }
+      _classPrivateFieldGet(_userGroupedConditions, this).splice(index, 1, condition);
+      _classPrivateFieldSet(_groupedConditions, this, this._applyGroups(_classPrivateFieldGet(_userGroupedConditions, this)));
+      return this;
+    }
+    remove(indexes) {
+      _classPrivateFieldSet(_userGroupedConditions, this, _classPrivateFieldGet(_userGroupedConditions, this).filter((_condition, index) => !indexes.includes(index)).map((condition, index) => index === 0 ? condition.asFirstCondition() : condition));
+      _classPrivateFieldSet(_groupedConditions, this, this._applyGroups(_classPrivateFieldGet(_userGroupedConditions, this)));
+      return this;
+    }
+    addGroups(groupDefs) {
+      _classPrivateFieldSet(_userGroupedConditions, this, this._group(_classPrivateFieldGet(_userGroupedConditions, this), groupDefs));
+      _classPrivateFieldSet(_groupedConditions, this, this._applyGroups(_classPrivateFieldGet(_userGroupedConditions, this)));
+      return this;
+    }
+    splitGroup(index) {
+      _classPrivateFieldSet(_userGroupedConditions, this, this._ungroup(_classPrivateFieldGet(_userGroupedConditions, this), index));
+      _classPrivateFieldSet(_groupedConditions, this, this._applyGroups(_classPrivateFieldGet(_userGroupedConditions, this)));
+      return this;
+    }
+    moveEarlier(index) {
+      if (index > 0 && index < _classPrivateFieldGet(_userGroupedConditions, this).length) {
+        _classPrivateFieldGet(_userGroupedConditions, this).splice(index - 1, 0, _classPrivateFieldGet(_userGroupedConditions, this).splice(index, 1)[0]);
+        if (index === 1) {
+          this.switchCoordinators();
+        }
+        _classPrivateFieldSet(_groupedConditions, this, this._applyGroups(_classPrivateFieldGet(_userGroupedConditions, this)));
+      }
+      return this;
+    }
+    moveLater(index) {
+      if (index >= 0 && index < _classPrivateFieldGet(_userGroupedConditions, this).length - 1) {
+        _classPrivateFieldGet(_userGroupedConditions, this).splice(index + 1, 0, _classPrivateFieldGet(_userGroupedConditions, this).splice(index, 1)[0]);
+        if (index === 0) {
+          this.switchCoordinators();
+        }
+        _classPrivateFieldSet(_groupedConditions, this, this._applyGroups(_classPrivateFieldGet(_userGroupedConditions, this)));
+      }
+      return this;
+    }
+    switchCoordinators() {
+      _classPrivateFieldGet(_userGroupedConditions, this)[1].setCoordinator(_classPrivateFieldGet(_userGroupedConditions, this)[0].getCoordinator());
+      _classPrivateFieldGet(_userGroupedConditions, this)[0].setCoordinator(undefined);
+    }
+    get asPerUserGroupings() {
+      return [..._classPrivateFieldGet(_userGroupedConditions, this)];
+    }
+    get hasConditions() {
+      return _classPrivateFieldGet(_userGroupedConditions, this).length > 0;
+    }
+    get lastIndex() {
+      return _classPrivateFieldGet(_userGroupedConditions, this).length - 1;
+    }
+    toPresentationString() {
+      return _classPrivateFieldGet(_groupedConditions, this).map(condition => toPresentationString(condition)).join(' ');
+    }
+    toExpression() {
+      return _classPrivateFieldGet(_groupedConditions, this).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 = _classPrivateFieldGet(_conditionName, this);
+      const conditions = _classPrivateFieldGet(_userGroupedConditions, this);
+      return {
+        name,
+        conditions: conditions.map(it => it.clone())
+      };
+    }
+    static from(obj) {
+      if (obj instanceof ConditionsModel) {
+        return obj;
+      }
+      const toReturn = new ConditionsModel();
+      _classPrivateFieldSet(_conditionName, toReturn, obj.name);
+      _classPrivateFieldSet(_userGroupedConditions, toReturn, obj.conditions.map(it => conditionFrom(it)));
+      _classPrivateFieldSet(_groupedConditions, toReturn, toReturn._applyGroups(_classPrivateFieldGet(_userGroupedConditions, toReturn)));
+      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) {
+      _defineProperty(this, "first", void 0);
+      _defineProperty(this, "last", void 0);
+      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) {
+      _defineProperty(this, "conditions", void 0);
+      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) {
+      _defineProperty(this, "name", void 0);
+      _defineProperty(this, "type", void 0);
+      _defineProperty(this, "display", void 0);
+      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) {
+      _defineProperty(this, "coordinator", void 0);
+      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);
+      _defineProperty(this, "field", void 0);
+      _defineProperty(this, "operator", void 0);
+      _defineProperty(this, "value", void 0);
+      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);
+      _defineProperty(this, "conditionName", void 0);
+      _defineProperty(this, "conditionDisplayName", void 0);
+      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