@zohodesk/library-platform 1.0.0 → 1.0.2-exp.1.0

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import RowActionsRenderer from '../../../row-actions-renderer/frameworks/ui/RowActionsRenderer';
+import { ComponentRegistry } from '@library/index';
+import { IState } from '../../domain/entities/interfaces/IState';
+import ActionViewModel, { ActionViewGap } from '../../../interfaces/ActionViewModel';
+
+export default function ActionEventMediatorView({ state }: { state: IState }, ref) {
+
+  const { actions, renderComponentType, gap }: { actions: ActionViewModel[], renderComponentType: string, gap: ActionViewGap } = state.properties;
+
+  const ActionRenderComponent = ComponentRegistry.get(renderComponentType) || RowActionsRenderer;
+
+  return (
+    <ActionRenderComponent actions={actions} gap={gap} getRef={ref} />
+  );
+
+}

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

@@ -0,0 +1,36 @@
+import EventHandlers from '@cc/component/EventHandlers';
+
+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';
+import IRepository from '../../applications/interfaces/gateways/IRepository';
+import IPresenter from '../../applications/interfaces/output/IPresenter';
+
+export default class EventHandlersFactory {
+  static create(): EventHandlers {
+    const repository: IRepository = new Repository();
+    const presenter: IPresenter = new Presenter();
+    const dependencies: { repository: IRepository; presenter: IPresenter } = { repository, presenter };
+
+    const initializeUseCase: InitializeUseCase = new InitializeUseCase(dependencies);
+    const destroyUseCase: DestroyUseCase = new DestroyUseCase(dependencies);
+    const propertiesChangeUseCase: PropertiesChangeUseCase = new PropertiesChangeUseCase(dependencies);
+
+    const initializeController: MountController = new MountController(initializeUseCase);
+    const unmountController: UnmountController = new UnmountController(destroyUseCase);
+    const propertiesChangeController: 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/domain/entities/interfaces/IState.ts

@@ -0,0 +1,5 @@
+import ActionViewModel from "../../../../interfaces/ActionViewModel";
+
+
+
+export type IState = { properties: { action: ActionViewModel }; handlers: object }

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

@@ -0,0 +1,10 @@
+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.tsx

@@ -0,0 +1,19 @@
+import React from 'react';
+import ComponentRegistry from '@library/custom-component/frameworks/ui/ComponentRegistry';
+import { IState } from '../../domain/entities/interfaces/IState';
+import ActionViewModel from '../../../interfaces/ActionViewModel';
+import ActionComponentMapping from '@library/dot/components/action-location/frameworks/ui/ActionComponentMapping';
+
+function DynamicComponentView({ state }: { state: IState }, ref) {
+  const { action }: { action: ActionViewModel } = state.properties;
+  const { component, properties, eventMappings }: ActionViewModel = action;
+  const Component = ComponentRegistry.get(component) || ActionComponentMapping[component];
+
+  if (!Component) {
+    return <div ref={ref}>Error</div>;
+  }
+
+  return <Component getRef={ref} {...properties} appendToActionPayload={{ eventMappings }} />;
+}
+
+export default DynamicComponentView;

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

@@ -0,0 +1,17 @@
+import EventMappingViewModel from './EventMappingViewModel';
+
+export interface Properties { }
+
+export default interface ActionViewModel {
+  component: string;
+  properties: Properties;
+  eventMappings: EventMappingViewModel[];
+  id: string
+}
+
+export enum ActionViewGap {
+  NONE = 'none',
+  SMALL = 'small',
+  MEDIUM = 'medium',
+  LARGE = 'large'
+}

package/es/platform/client-actions/components/interfaces/EventMappingViewModel.ts

@@ -0,0 +1,7 @@
+
+export default interface EventMappingViewModel {
+  id: string;
+  sourceEvent: string;
+  targetEvent: string;
+  payload: any;
+}

package/es/platform/client-actions/components/row-actions-renderer/domain/entities/interfaces/IState.ts

@@ -0,0 +1,5 @@
+import ActionViewModel, { ActionViewGap } from "../../../../interfaces/ActionViewModel";
+
+
+
+export type IState = { properties: { actions: ActionViewModel[], gap: ActionViewGap }; handlers: object }

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/RowActionsRenderer.ts

@@ -0,0 +1,17 @@
+import { createCustomComponent } from '@library/custom-component';
+import RowActionsRendererProperties from '../../../../cc/action-event-mediator/Properties';
+import RowActionsRendererView from './RowActionsRendererView';
+import { ComponentRegistry } from '@library/index';
+
+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/RowActionsRendererView.tsx

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

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

@@ -0,0 +1,43 @@
+import { ITemplate } from "./interfaces/ITemplate";
+
+
+
+export default class TemplateResolver {
+    static getPathValue(path: string, obj: ITemplate): string | number | boolean | object | undefined {
+        return path.split('.').reduce(function (prev, curr) {
+            return prev !== undefined ? prev[curr] : undefined;
+        }, obj);
+    }
+
+    static replaceContextVariables(inputString: string, replacementObj: ITemplate): string {
+        return inputString.replace(/{{(.*?)}}/g, (match: string, key: string) => {
+            let value: string | number | boolean | object | undefined = this.getPathValue(key.trim(), replacementObj);
+            if (Array.isArray(value) || value instanceof Object) {
+                return JSON.stringify(value);
+            }
+            return value !== undefined ? value.toString() : match;
+        });
+    }
+
+    private static isOnlyContextVariables(inputString: string): boolean {
+        return /^{{(.*?)}}$/.test(inputString);
+    }
+
+    static replaceContextVariablesInObject(properties: Object, replacementObj: Object): Object {
+        const replaced: object = {};
+        Object.entries(properties).forEach(([key, value]) => {
+            if (typeof value === 'string' && this.isOnlyContextVariables(value)) {
+                const path: string = value.replace(/{{(.*?)}}/g, '$1');
+                const pathValue: string | number | boolean | object | undefined = 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.ts

@@ -0,0 +1 @@
+export type ITemplate = object;

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

@@ -0,0 +1,39 @@
+
+
+import { ClientActionModel } from '../../behaviour/zclient-actions/domain/entities/interfaces/ClientActionModel';
+import { EventMappingModel } from '../../behaviour/zclient-actions/domain/entities/interfaces/EventMappingModel';
+import ActionViewModel from '../../components/interfaces/ActionViewModel';
+import { ActionContextResolver } from '../context-resolver';
+import EventMappingViewModel from '../../components/interfaces/EventMappingViewModel';
+import { ConditionResolver } from '../condition-resolver';
+
+
+export default class ClientActionsTranslator {
+
+    constructor() {
+    }
+
+    private static transformToActionViewModel(action: ClientActionModel): ActionViewModel {
+        return {
+            id: action.id,
+            component: action.uiComponentMapping.component,
+            properties: action.uiComponentMapping.propertiesValueMapping,
+            eventMappings: action.uiComponentMapping.eventMappings.map((eventMapping: EventMappingModel): EventMappingViewModel => {
+                return {
+                    sourceEvent: eventMapping.sourceEvent,
+                    id: eventMapping.id,
+                    targetEvent: eventMapping.targetEvent,
+                    payload: eventMapping.payloadValueMapping
+                }
+            })
+        }
+    }
+
+    public static transform(actions: ClientActionModel[], context: object): ActionViewModel[] {
+        const resolvedActions = ActionContextResolver.resolveActions(actions, context);
+        const evaluatedActions = resolvedActions.filter((action: ClientActionModel) => 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.ts

@@ -0,0 +1,5 @@
+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.ts

@@ -0,0 +1,5 @@
+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.ts

@@ -0,0 +1,5 @@
+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.ts

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

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

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

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

@@ -0,0 +1,7 @@
+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.ts

@@ -0,0 +1,5 @@
+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.ts

@@ -0,0 +1,5 @@
+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.ts

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

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

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

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

@@ -0,0 +1,5 @@
+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.ts

@@ -0,0 +1,5 @@
+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.ts

@@ -0,0 +1,5 @@
+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.ts

@@ -0,0 +1,5 @@
+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.ts

@@ -0,0 +1,8 @@
+export function getResolvedContextFieldValue(context, field) {
+    if (field.includes(".")) {
+        let value: string | number | boolean = 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.ts

@@ -0,0 +1,59 @@
+import { ConditionFieldModel } from "../../../behaviour/zclient-actions/domain/entities/interfaces/ConditionFieldModel";
+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";
+import { IContext } from "../../interfaces/IContext";
+
+const opers: Record<string, Function> = {
+    '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: Record<string, Function> = {
+    '=': 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: ConditionFieldModel[], context: IContext): boolean[] {
+    return conditions.map(({ fieldName, condition, value }: ConditionFieldModel) => {
+        const resolvedValue: string = value.join(',');
+        if (fieldName == null && value == null || value.length == 0) return true;
+        return platformOpers[condition](fieldName, resolvedValue, context)
+    })
+}
+

package/es/platform/client-actions/translators/condition-resolver/index.ts

@@ -0,0 +1,24 @@
+import { ConditionModel } from "../../behaviour/zclient-actions/domain/entities/interfaces/ConditionModel";
+import { patternValidate } from "./pattern-evaluator/PatternValidator";
+import { evaluateConditionsFields } from "./field-evaluators";
+import { evaluateExpression, parse } from "./pattern-evaluator";
+
+export class ConditionResolver {
+    static evaluateCondition(condition: ConditionModel, context, id: string): boolean {
+        const { fields = [], pattern = '' } = condition;
+        if (fields.length > 0 && pattern.length > 0) {
+            const { isValid, errorMessage, pattern: validatedPattern } = patternValidate(pattern, fields.length);
+            if (!isValid) {
+                console.error(`Error in client action id ${id} -  condition pattern`, errorMessage);
+                return false;
+            }
+            const resolvedFields = evaluateConditionsFields(fields, context);
+            const transformedPattern = validatedPattern.replace(/and/g, '&&').replace(/or/g, '||');
+            const ast = parse(transformedPattern);
+            const isValidCondition = evaluateExpression(ast, resolvedFields);
+            return isValidCondition;
+        }
+
+        return true;
+    }
+}

package/es/platform/client-actions/translators/condition-resolver/pattern-evaluator/PatternValidator.ts

@@ -0,0 +1,84 @@
+/* eslint-disable max-lines-per-function */
+export function patternValidate(patternString: string = '', conditionsLength: number): {
+    isValid: boolean,
+    errorMessage?: string,
+    pattern?: string
+} {
+    if (!patternString.trim()) {
+        return {
+            errorMessage: 'Pattern cannot be empty',
+            isValid: false
+        };
+    }
+    const isValid: boolean = true;
+    const patternStr: string = patternString.replace(/\s+/g, '');
+
+    const openBracketsLen: number = (patternStr.match(/\(/gi) || []).length;
+    const closeBractsLen: number = (patternStr.match(/\)/gi) || []).length;
+    if (openBracketsLen !== closeBractsLen) {
+        return {
+            errorMessage: 'Pattern brackets do not match',
+            isValid: false
+        };
+    }
+
+    let brackStr: string = patternStr.replace(/#/g, '~');
+    brackStr = patternStr.replace(/(and|or)/g, '#');
+
+    if (brackStr.indexOf('(#') !== -1 || brackStr.indexOf('#)') !== -1) {
+        return {
+            errorMessage: 'Invalid brackets surrounding condition operator(s).',
+            isValid: false
+        };
+    }
+    if (brackStr.indexOf('()') !== -1) {
+        return {
+            errorMessage: 'Pattern brackets do not match',
+            isValid: false
+        };
+    }
+
+    const matchedNumbers: string[] = patternStr.match(/[0-9]+/g);
+    const patternNumbers: string[] = matchedNumbers ? matchedNumbers : [];
+    const patternNumbersLen: number = patternNumbers.length;
+    for (let i: number = 0; i < patternNumbersLen; i++) {
+        const currentNumber: number = parseInt(patternNumbers[i]);
+        if (currentNumber !== i + 1) {
+            return {
+                errorMessage: 'Please check the conditions number in the pattern.',
+                isValid: false
+            };
+        }
+    }
+
+    const patternEmpty: string = brackStr
+        .replace(/[()]/g, '#')
+        .replace(/[0-9]+/g, '#')
+        .replace(/#/g, '');
+    if (patternEmpty && patternEmpty.length >= 1) {
+        return {
+            errorMessage: 'Invalid content in this pattern',
+            isValid: false
+        };
+    }
+
+    const andOrCount: number = (patternStr.match(/(and|or)/gi) || []).length;
+    if (conditionsLength - 1 !== andOrCount) {
+        return {
+            errorMessage: 'Number of conditions in this pattern do not match with the conditions entered',
+            isValid: false
+        };
+    }
+
+    if (patternNumbersLen !== conditionsLength) {
+        return {
+            errorMessage: 'Number of conditions in this pattern do not match with the conditions given.',
+            isValid: false
+        };
+    }
+
+    return {
+        isValid,
+        pattern: patternStr
+    };
+}

package/es/platform/client-actions/translators/condition-resolver/pattern-evaluator/index.ts

@@ -0,0 +1,78 @@
+/* eslint-disable max-lines-per-function */
+import jsep from 'jsep';
+
+const binops: Record<string, Function> = {
+    '||': function (a, b) { return a || b; },
+    '&&': function (a, b) { return a && b; }
+};
+
+const unops: Record<string, Function> = {
+    '-': function (a) { return -a; },
+    '+': function (a) { return +a; },
+    '~': function (a) { return ~a; },
+    '!': function (a) { return !a; },
+};
+
+function evaluateArray(list, context) {
+    return list.map(function (v) { return evaluate(v, context); });
+}
+
+function evaluateMember(node, context) {
+    const object: object = evaluate(node.object, context);
+    if (node.computed) {
+        return [object, object[evaluate(node.property, context)]];
+    } else {
+        return [object, object[node.property.name]];
+    }
+}
+
+function evaluate(node, context) {
+    switch (node.type) {
+        case 'ArrayExpression':
+            return evaluateArray(node.elements, context);
+        case 'BinaryExpression':
+            return binops[node.operator](evaluate(node.left, context), evaluate(node.right, context));
+        case 'CallExpression':
+            let caller, fn, assign;
+            if (node.callee.type === 'MemberExpression') {
+                assign = evaluateMember(node.callee, context);
+                caller = assign[0];
+                fn = assign[1];
+            } else {
+                fn = evaluate(node.callee, context);
+            }
+            if (typeof fn !== 'function') { return undefined; }
+            return fn.apply(caller, evaluateArray(node.arguments, context));
+        case 'ConditionalExpression':
+            return evaluate(node.test, context) ? evaluate(node.consequent, context) : evaluate(node.alternate, context);
+
+        case 'Literal':
+            return context[node.value - 1];
+
+        case 'LogicalExpression':
+            if (node.operator === '||') {
+                return evaluate(node.left, context) || evaluate(node.right, context);
+            } else if (node.operator === '&&') {
+                return evaluate(node.left, context) && evaluate(node.right, context);
+            }
+            return binops[node.operator](evaluate(node.left, context), evaluate(node.right, context));
+
+        case 'MemberExpression':
+            return evaluateMember(node, context)[1];
+
+        case 'ThisExpression':
+            return context;
+
+        case 'UnaryExpression':
+            return unops[node.operator](evaluate(node.argument, context));
+
+        default:
+            return undefined;
+    }
+
+}
+
+export {
+    jsep as parse,
+    evaluate as evaluateExpression
+};