@zohodesk/library-platform 1.1.0-exp.2 → 1.1.0

package/es/platform/client-actions/components/action-event-mediator/adapters/gateway/Repository.js

@@ -0,0 +1,36 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import ActionEventMediatorEntity from "../../domain/entities/ActionEventMediatorEntity";
+export default class Repository {
+  init(state) {
+    this.state = state;
+  }
+
+  constructor() {
+    _defineProperty(this, "element", void 0);
+
+    _defineProperty(this, "dispatch", void 0);
+
+    _defineProperty(this, "state", void 0);
+
+    this.element = null;
+  }
+
+  updateDependencies(element, state, dispatch) {
+    this.element = element;
+    this.dispatch = dispatch;
+    this.state = state;
+  }
+
+  getActionEventMediator() {
+    const {
+      actions
+    } = this.state.properties;
+    const {
+      handlers
+    } = this.state;
+    const actionEventMediator = new ActionEventMediatorEntity(handlers, actions, this.element, this.dispatch);
+    return actionEventMediator;
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/adapters/presenters/Presenter.js

@@ -0,0 +1,22 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+export default class Presenter {
+  constructor() {
+    _defineProperty(this, "updateState", void 0);
+
+    _defineProperty(this, "state", void 0);
+  }
+
+  updateDependencies(state, updateState) {
+    this.updateState = updateState;
+    this.state = state;
+  }
+
+  updateActionEventMediator(newState) {
+    this.state = { ...this.state,
+      ...newState
+    };
+    this.updateState(this.state);
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/applications/usecases/AbstractUseCase.js

@@ -0,0 +1,15 @@
+export class AbstractUseCase {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+
+  updateDependencies(element, state, dispatch, updateState) {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    repository.updateDependencies(element, state, dispatch);
+    presenter.updateDependencies(state, updateState);
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/applications/usecases/DestroyUseCase.js

@@ -0,0 +1,13 @@
+import { AbstractUseCase } from "./AbstractUseCase";
+export default class DestroyUseCase extends AbstractUseCase {
+  execute() {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const actionLocation = repository.getActionEventMediator();
+    actionLocation.destroy();
+    presenter.updateActionEventMediator(actionLocation.toObject());
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/applications/usecases/InitializeUseCase.js

@@ -0,0 +1,13 @@
+import { AbstractUseCase } from "./AbstractUseCase";
+export default class InitializeUseCase extends AbstractUseCase {
+  execute() {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const actionLocation = repository.getActionEventMediator();
+    actionLocation.initialize();
+    presenter.updateActionEventMediator(actionLocation.toObject());
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/applications/usecases/PropertiesChangeUseCase.js

@@ -0,0 +1,17 @@
+import { AbstractUseCase } from "./AbstractUseCase";
+export default class PropertiesChangeUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const actionLocation = repository.getActionEventMediator();
+    const {
+      currentActions,
+      previousActions
+    } = input;
+    actionLocation.processActionsChange(currentActions, previousActions);
+    presenter.updateActionEventMediator(actionLocation.toObject());
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/domain/entities/ActionEventMediatorEntity.js

@@ -0,0 +1,108 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import TemplateResolver from "../../../../template-resolver";
+export default class ActionEventMediatorEntity {
+  constructor(handlers, actions, element, dispatch) {
+    this.handlers = handlers;
+    this.actions = actions;
+    this.element = element;
+    this.dispatch = dispatch;
+
+    _defineProperty(this, "contextResolver", void 0);
+  }
+
+  createEventHandlers(event) {
+    // TODO: this code needs to move to custom component or somewhere else
+    return e => {
+      const {
+        eventMappings,
+        ...payloadItems
+      } = e.detail.payload;
+      const eventMapping = eventMappings.find(eventMapping => eventMapping.sourceEvent === event);
+
+      if (!eventMapping) {
+        return;
+      }
+
+      const dispatchEvent = eventMapping.targetEvent;
+      const payload = eventMapping.payload;
+      const replacementContext = {
+        "@payload": payloadItems
+      };
+      const resolvedPayload = TemplateResolver.replaceContextVariablesInObject(payload, replacementContext);
+      this.dispatch({
+        type: dispatchEvent,
+        payload: resolvedPayload
+      });
+    };
+  }
+
+  getEventNames(actions) {
+    const eventNames = [];
+    actions.forEach(action => {
+      action.eventMappings.forEach(eventMapping => {
+        if (!eventNames.includes(eventMapping.sourceEvent)) {
+          eventNames.push(eventMapping.sourceEvent);
+        }
+      });
+    });
+    return eventNames;
+  }
+
+  listen(eventName) {
+    var _this$element;
+
+    const handler = this.createEventHandlers(eventName);
+    this.handlers[eventName] = handler;
+    (_this$element = this.element) === null || _this$element === void 0 ? void 0 : _this$element.addEventListener(eventName, handler);
+  }
+
+  unListen(eventName) {
+    var _this$element2;
+
+    const handler = this.handlers[eventName];
+    (_this$element2 = this.element) === null || _this$element2 === void 0 ? void 0 : _this$element2.removeEventListener(eventName, handler);
+    this.handlers[eventName] = undefined;
+  }
+
+  compareEventNames(previousEventNames, currentEventNames) {
+    return previousEventNames.length === currentEventNames.length && previousEventNames.every((eventName, index) => eventName === currentEventNames[index]);
+  }
+
+  initialize() {
+    const eventNames = this.getEventNames(this.actions);
+    eventNames.forEach(eventName => {
+      this.listen(eventName);
+    });
+  }
+
+  processActionsChange(previousActions, currentActions) {
+    const previousEventNames = this.getEventNames(previousActions).sort();
+    const currentEventNames = this.getEventNames(currentActions).sort();
+
+    if (this.compareEventNames(previousEventNames, currentEventNames)) {
+      return;
+    }
+
+    previousEventNames.forEach(eventName => {
+      this.unListen(eventName);
+    });
+    currentEventNames.forEach(eventName => {
+      this.listen(eventName);
+    });
+  }
+
+  destroy() {
+    const eventNames = this.getEventNames(this.actions);
+    eventNames.forEach(eventName => {
+      this.unListen(eventName);
+    });
+  }
+
+  toObject() {
+    return {
+      handlers: this.handlers
+    };
+  }
+
+}

package/es/platform/client-actions/components/action-event-mediator/frameworks/ui/ActionEventMediator.js

@@ -0,0 +1,13 @@
+import { createCustomComponent } from "../../../../../../library/custom-component";
+import ActionEventMediatorProperties from "../../../../cc/action-event-mediator/Properties";
+import EventHandlersFactory from "./EventHandlersFactory";
+import ActionEventMediatorView from "./ActionEventMediatorView";
+export default createCustomComponent({
+  name: 'ActionEventMediator',
+  properties: ActionEventMediatorProperties,
+  setInitialState: () => ({
+    handlers: {}
+  }),
+  eventHandlers: EventHandlersFactory.create(),
+  View: ActionEventMediatorView
+});

package/es/platform/client-actions/components/action-event-mediator/frameworks/ui/ActionEventMediatorView.js

@@ -0,0 +1,19 @@
+import React from 'react';
+import RowActionsRenderer from "../../../row-actions-renderer/frameworks/ui/RowActionsRenderer";
+import { ComponentRegistry } from "../../../../../../library";
+export default function ActionEventMediatorView(_ref, ref) {
+  let {
+    state
+  } = _ref;
+  const {
+    actions,
+    renderComponentType,
+    gap
+  } = state.properties;
+  const ActionRenderComponent = ComponentRegistry.get(renderComponentType) || RowActionsRenderer;
+  return /*#__PURE__*/React.createElement(ActionRenderComponent, {
+    actions: actions,
+    gap: gap,
+    getRef: ref
+  });
+}

package/es/platform/client-actions/components/action-event-mediator/frameworks/ui/EventHandlersFactory.js

@@ -0,0 +1,30 @@
+import Repository from "../../adapters/gateway/Repository";
+import Presenter from "../../adapters/presenters/Presenter";
+import InitializeUseCase from "../../applications/usecases/InitializeUseCase";
+import DestroyUseCase from "../../applications/usecases/DestroyUseCase";
+import PropertiesChangeUseCase from "../../applications/usecases/PropertiesChangeUseCase";
+import MountController from "../../adapters/controllers/MountController";
+import UnmountController from "../../adapters/controllers/UnmountController";
+import PropertiesChangeController from "../../adapters/controllers/PropertiesChangeController";
+export default class EventHandlersFactory {
+  static create() {
+    const repository = new Repository();
+    const presenter = new Presenter();
+    const dependencies = {
+      repository,
+      presenter
+    };
+    const initializeUseCase = new InitializeUseCase(dependencies);
+    const destroyUseCase = new DestroyUseCase(dependencies);
+    const propertiesChangeUseCase = new PropertiesChangeUseCase(dependencies);
+    const initializeController = new MountController(initializeUseCase);
+    const unmountController = new UnmountController(destroyUseCase);
+    const propertiesChangeController = new PropertiesChangeController(propertiesChangeUseCase);
+    return {
+      ['ActionEventMediator#MOUNT']: initializeController.handle,
+      ['ActionEventMediator#UPDATE_PROPERTIES']: propertiesChangeController.handle,
+      ['ActionEventMediator#UNMOUNT']: unmountController.handle
+    };
+  }
+
+}

package/es/platform/client-actions/components/dynamic-component/frameworks/ui/DynamicActionComponent.js

@@ -0,0 +1,9 @@
+import { createCustomComponent } from "../../../../../../library/custom-component";
+import DynamicActionComponentProperties from "../../../../cc/dynamic-action-component/Properties";
+import DynamicActionComponentView from "./DynamicActionComponentView";
+export default createCustomComponent({
+  name: 'DynamicActionComponent',
+  properties: DynamicActionComponentProperties,
+  eventHandlers: {},
+  View: DynamicActionComponentView
+});

package/es/platform/client-actions/components/dynamic-component/frameworks/ui/DynamicActionComponentView.js

@@ -0,0 +1,34 @@
+import React from 'react';
+import ComponentRegistry from "../../../../../../library/custom-component/frameworks/ui/ComponentRegistry";
+import ActionComponentMapping from "../../../../../../library/dot/components/action-location/frameworks/ui/ActionComponentMapping";
+
+function DynamicComponentView(_ref, ref) {
+  let {
+    state
+  } = _ref;
+  const {
+    action
+  } = state.properties;
+  const {
+    component,
+    properties,
+    eventMappings
+  } = action;
+  const Component = ComponentRegistry.get(component) || ActionComponentMapping[component];
+
+  if (!Component) {
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref
+    }, "Error");
+  }
+
+  return /*#__PURE__*/React.createElement(Component, {
+    getRef: ref,
+    ...properties,
+    appendToActionPayload: {
+      eventMappings
+    }
+  });
+}
+
+export default DynamicComponentView;

package/es/platform/client-actions/components/interfaces/ActionViewModel.js

@@ -0,0 +1,7 @@
+export let ActionViewGap = /*#__PURE__*/function (ActionViewGap) {
+  ActionViewGap["NONE"] = "none";
+  ActionViewGap["SMALL"] = "small";
+  ActionViewGap["MEDIUM"] = "medium";
+  ActionViewGap["LARGE"] = "large";
+  return ActionViewGap;
+}({});

package/es/platform/client-actions/components/row-actions-renderer/frameworks/ui/RowActionsRenderer.js

@@ -0,0 +1,12 @@
+import { createCustomComponent } from "../../../../../../library/custom-component";
+import RowActionsRendererProperties from "../../../../cc/action-event-mediator/Properties";
+import RowActionsRendererView from "./RowActionsRendererView";
+import { ComponentRegistry } from "../../../../../../library";
+const RowActionsRendererComponent = createCustomComponent({
+  name: 'RowActionsRenderer',
+  properties: RowActionsRendererProperties,
+  eventHandlers: {},
+  View: RowActionsRendererView
+});
+ComponentRegistry.register("RowActionsRenderer", RowActionsRendererComponent);
+export default RowActionsRendererComponent;

package/es/platform/client-actions/components/row-actions-renderer/frameworks/ui/RowActionsRenderer.module.css

@@ -0,0 +1,17 @@
+[dir=ltr] .actions {
+    padding-left: var(--zd_size4) 
+}[dir=rtl] .actions {
+    padding-right: var(--zd_size4) 
+}
+
+.gap_small {
+    gap: var(--zd_size4) 
+}
+
+.gap_medium {
+    gap: var(--zd_size8) 
+}
+
+.gap_large {
+    gap: var(--zd_size12) 
+}

package/es/platform/client-actions/components/row-actions-renderer/frameworks/ui/RowActionsRendererView.js

@@ -0,0 +1,30 @@
+import React from 'react';
+import Flex from '@zohodesk/layout/es/Flex/Flex';
+import DynamicActionComponent from "../../../dynamic-component/frameworks/ui/DynamicActionComponent";
+import { ActionViewGap } from "../../../interfaces/ActionViewModel";
+// @ts-ignore
+import style from "./RowActionsRenderer.module.css";
+
+function RowActionsRendererView(_ref, ref) {
+  let {
+    state
+  } = _ref;
+  const {
+    actions,
+    gap
+  } = state.properties;
+  return /*#__PURE__*/React.createElement(Flex, {
+    ref: ref,
+    $ui_displayMode: "inline",
+    $ui_alignItems: "center",
+    $ui_className: `${style.actions} ${gap !== ActionViewGap.NONE ? style[`gap_${gap}`] : ''}`
+  }, actions.map((action, index) => {
+    return /*#__PURE__*/React.createElement(DynamicActionComponent, {
+      action: action,
+      key: index
+    });
+  }));
+}
+
+;
+export default RowActionsRendererView;

package/es/platform/client-actions/template-resolver/index.js

@@ -0,0 +1,44 @@
+export default class TemplateResolver {
+  static getPathValue(path, obj) {
+    return path.split('.').reduce(function (prev, curr) {
+      return prev !== undefined ? prev[curr] : undefined;
+    }, obj);
+  }
+
+  static replaceContextVariables(inputString, replacementObj) {
+    return inputString.replace(/{{(.*?)}}/g, (match, key) => {
+      let value = this.getPathValue(key.trim(), replacementObj);
+
+      if (Array.isArray(value) || value instanceof Object) {
+        return JSON.stringify(value);
+      }
+
+      return value !== undefined ? value.toString() : match;
+    });
+  }
+
+  static isOnlyContextVariables(inputString) {
+    return /^{{(.*?)}}$/.test(inputString);
+  }
+
+  static replaceContextVariablesInObject(properties, replacementObj) {
+    const replaced = {};
+    Object.entries(properties).forEach(_ref => {
+      let [key, value] = _ref;
+
+      if (typeof value === 'string' && this.isOnlyContextVariables(value)) {
+        const path = value.replace(/{{(.*?)}}/g, '$1');
+        const pathValue = this.getPathValue(path, replacementObj);
+        replaced[key] = pathValue !== undefined ? pathValue : `{{${path}}}`;
+      } else if (typeof value === 'string' && value.includes('{{')) {
+        replaced[key] = this.replaceContextVariables(value, replacementObj);
+      } else if (typeof value === 'object' && value !== null) {
+        replaced[key] = this.replaceContextVariablesInObject(value, replacementObj);
+      } else {
+        replaced[key] = value;
+      }
+    });
+    return Array.isArray(properties) ? Object.values(replaced) : replaced;
+  }
+
+}

package/es/platform/client-actions/template-resolver/interfaces/ITemplate.js

@@ -0,0 +1 @@
+export {};

package/es/platform/client-actions/translators/client-actions-translator/index.js

@@ -0,0 +1,29 @@
+import { ActionContextResolver } from "../context-resolver";
+import { ConditionResolver } from "../condition-resolver";
+export default class ClientActionsTranslator {
+  constructor() {}
+
+  static transformToActionViewModel(action) {
+    return {
+      id: action.id,
+      component: action.uiComponentMapping.component,
+      properties: action.uiComponentMapping.propertiesValueMapping,
+      eventMappings: action.uiComponentMapping.eventMappings.map(eventMapping => {
+        return {
+          sourceEvent: eventMapping.sourceEvent,
+          id: eventMapping.id,
+          targetEvent: eventMapping.targetEvent,
+          payload: eventMapping.payloadValueMapping
+        };
+      })
+    };
+  }
+
+  static transform(actions, context) {
+    const resolvedActions = ActionContextResolver.resolveActions(actions, context);
+    const evaluatedActions = resolvedActions.filter(action => ConditionResolver.evaluateCondition(action.conditions, context, action.id));
+    const finalTransformedActions = evaluatedActions.map(action => this.transformToActionViewModel(action));
+    return finalTransformedActions;
+  }
+
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalEmptyString.js

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalEmptyString(field, value, context) {
+  return getResolvedContextFieldValue(context, field) === '' || getResolvedContextFieldValue(context, field) === null;
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalEndsWith.js

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalEndsWith(field, value, context) {
+  return String(getResolvedContextFieldValue(context, field)).endsWith(String(value));
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalEquals.js

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalEquals(field, value, context) {
+  return String(getResolvedContextFieldValue(context, field)) === String(value);
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalGreaterThan.js

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalGreaterThan(field, value, context) {
+  return getResolvedContextFieldValue(context, field) > value;
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalGreaterThanOrEquals.js

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalGreaterThanOrEquals(field, value, context) {
+  return getResolvedContextFieldValue(context, field) >= value;
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalIn.js

@@ -0,0 +1,4 @@
+import { evalEquals } from "./EvalEquals";
+export function evalIn(field, value, context) {
+  return String(value).split(',').some(val => evalEquals(field, val, context));
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalIsEmpty.js

@@ -0,0 +1,4 @@
+import { evalEmptyString } from "./EvalEmptyString";
+export function evalIsEmpty(field, value, context) {
+  return evalEmptyString(field, value, context);
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalIsNotEmpty.js

@@ -0,0 +1,4 @@
+import { evalIsEmpty } from "./EvalIsEmpty";
+export function EvalIsNotEmpty(field, value, context) {
+  return !evalIsEmpty(field, value, context);
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalLessThan.js

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalLessThan(field, value, context) {
+  return getResolvedContextFieldValue(context, field) < value;
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalLessThanOrEquals.js

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalLessThanOrEquals(field, value, context) {
+  return getResolvedContextFieldValue(context, field) <= value;
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalLike.js

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalLike(field, value, context) {
+  return String(getResolvedContextFieldValue(context, field)).includes(String(value));
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalNotEquals.js

@@ -0,0 +1,4 @@
+import { evalEquals } from "./EvalEquals";
+export function evalNotEquals(field, value, context) {
+  return !evalEquals(field, value, context);
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalNotLike.js

@@ -0,0 +1,4 @@
+import { evalLike } from "./EvalLike";
+export function evalNotLike(field, value, context) {
+  return !evalLike(field, value, context);
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/EvalStartsWith.js

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalStartsWith(field, value, context) {
+  return String(getResolvedContextFieldValue(context, field)).startsWith(String(value));
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/GetResolvedContextFieldValue.js

@@ -0,0 +1,8 @@
+export function getResolvedContextFieldValue(context, field) {
+  if (field.includes(".")) {
+    let value = field.split(".").reduce((obj, key) => obj && obj[key], context);
+    return value;
+  }
+
+  return context[field];
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/index.js

@@ -0,0 +1,58 @@
+import { evalIsEmpty } from "./EvalIsEmpty";
+import { evalEmptyString } from "./EvalEmptyString";
+import { evalEndsWith } from "./EvalEndsWith";
+import { evalEquals } from "./EvalEquals";
+import { evalGreaterThan } from "./EvalGreaterThan";
+import { evalGreaterThanOrEquals } from "./EvalGreaterThanOrEquals";
+import { evalIn } from "./EvalIn";
+import { evalLike } from "./EvalLike";
+import { evalLessThan } from "./EvalLessThan";
+import { evalLessThanOrEquals } from "./EvalLessThanOrEquals";
+import { EvalIsNotEmpty } from "./EvalIsNotEmpty";
+import { evalNotEquals } from "./EvalNotEquals";
+import { evalNotLike } from "./EvalNotLike";
+import { evalStartsWith } from "./EvalStartsWith";
+const opers = {
+  'ISEMPTY': evalIsEmpty,
+  'EMPTYSTRING': evalEmptyString,
+  'ENDSWITH': evalEndsWith,
+  '=': evalEquals,
+  '>': evalGreaterThan,
+  '>=': evalGreaterThanOrEquals,
+  'IN': evalIn,
+  'LIKE': evalLike,
+  '<': evalLessThan,
+  '<=': evalLessThanOrEquals,
+  'ISNOTEMPTY': EvalIsNotEmpty,
+  '!=': evalNotEquals,
+  'NOT LIKE': evalNotLike,
+  'STARTSWITH': evalStartsWith
+};
+const platformOpers = {
+  '=': opers['='],
+  'is': opers['='],
+  'starts with': opers['STARTSWITH'],
+  'ends with': opers['ENDSWITH'],
+  'contains': opers['LIKE'],
+  "doesn't contain": opers['NOT LIKE'],
+  "is empty": opers["ISEMPTY"],
+  "is not empty": opers["ISNOTEMPTY"],
+  '<': opers['<'],
+  '>': opers['>'],
+  '<=': opers['<='],
+  '>=': opers['>='],
+  '<>': opers['!='],
+  'in': opers["IN"]
+};
+export function evaluateConditionsFields(conditions, context) {
+  return conditions.map(_ref => {
+    let {
+      fieldName,
+      condition,
+      value
+    } = _ref;
+    const resolvedValue = value.join(',');
+    if (fieldName == null && value == null || value.length == 0) return true;
+    return platformOpers[condition](fieldName, resolvedValue, context);
+  });
+}