copper-sdk 0.7.0 → 0.8.0

package/dist/copper-sdk.js

@@ -1,10 +1,10 @@
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
     typeof define === 'function' && define.amd ? define(factory) :
-    (global = global || self, global.Copper = factory());
-}(this, (function () { 'use strict';
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Copper = factory());
+})(this, (function () { 'use strict';
 
-    /*! *****************************************************************************
+    /******************************************************************************
     Copyright (c) Microsoft Corporation.
 
     Permission to use, copy, modify, and/or distribute this software for any
@@ -18,17 +18,8 @@
     OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
     PERFORMANCE OF THIS SOFTWARE.
     ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol */
 
-    var __assign = function() {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
 
     function __awaiter(thisArg, _arguments, P, generator) {
         function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -40,632 +31,522 @@
         });
     }
 
-    function __generator(thisArg, body) {
-        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-        function verb(n) { return function (v) { return step([n, v]); }; }
-        function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (_) try {
-                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-                if (y = 0, t) op = [op[0] & 2, t.value];
-                switch (op[0]) {
-                    case 0: case 1: t = op; break;
-                    case 4: _.label++; return { value: op[1], done: false };
-                    case 5: _.label++; y = op[1]; op = [0]; continue;
-                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                    default:
-                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                        if (t[2]) _.ops.pop();
-                        _.trys.pop(); continue;
-                }
-                op = body.call(thisArg, _);
-            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-        }
-    }
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
 
-    var version = "0.7.0";
+    var version = "0.8.0";
 
-    var ENTITY_PATH_MAP = {
-        lead: 'leads',
-        person: 'people',
-        company: 'companies',
-        opportunity: 'opportunities',
-        task: 'tasks',
-        project: 'projects',
+    const ENTITY_PATH_MAP = {
+        lead: 'leads',
+        person: 'people',
+        company: 'companies',
+        opportunity: 'opportunities',
+        task: 'tasks',
+        project: 'projects',
     };
 
-    var UITarget;
-    (function (UITarget) {
-        UITarget["ActivityLog"] = "ActivityLog";
-        UITarget["ListView"] = "ListView";
-        UITarget["Related"] = "Related";
+    var UITarget;
+    (function (UITarget) {
+        UITarget["ActivityLog"] = "ActivityLog";
+        UITarget["ListView"] = "ListView";
+        UITarget["Related"] = "Related";
     })(UITarget || (UITarget = {}));
 
-    function logActivityDataGenerator(context, _a) {
-        var activityType = _a.activityType, details = _a.details, activityDate = _a.activityDate;
-        var url = '/v1/activities';
-        var data = {
-            parent: {
-                type: context.type,
-                id: context.id,
-            },
-            type: {
-                category: 'user',
-                id: activityType,
-            },
-            details: details,
-        };
-        if (activityDate) {
-            data.activity_date = activityDate;
-        }
-        return {
-            url: url,
-            method: 'POST',
-            data: data,
-            target: {
-                name: UITarget.ActivityLog,
-            },
-        };
-    }
-    function createEntityDataGenerator(context, _a) {
-        var entityType = _a.entityType, data = _a.data;
-        var url = "/v1/" + ENTITY_PATH_MAP[entityType];
-        var target = entityType === context.type
-            ? {
-                name: UITarget.ListView,
-                data: {
-                    entityType: entityType,
-                    entityData: data,
-                },
-            }
-            : null;
-        return {
-            url: url,
-            method: 'POST',
-            data: data,
-            target: target,
-        };
-    }
-    function relateEntityDataGenerator(context, _a) {
-        var entityType = _a.entityType, entityId = _a.entityId, data = _a.data;
-        var url = "/v1/" + ENTITY_PATH_MAP[entityType] + "/" + entityId + "/related";
-        var isCurrentEntity = entityType === context.type && entityId === context.id;
-        var target = isCurrentEntity
-            ? {
-                name: UITarget.Related,
-                data: data,
-            }
-            : null;
-        return {
-            url: url,
-            method: 'POST',
-            data: {
-                resource: data,
-            },
-            target: target,
-        };
+    function logActivityDataGenerator(context, { activityType, details, activityDate, }) {
+        const url = '/v1/activities';
+        const data = {
+            parent: {
+                type: context.type,
+                id: context.id,
+            },
+            type: {
+                category: 'user',
+                id: activityType,
+            },
+            details,
+        };
+        if (activityDate) {
+            data.activity_date = activityDate;
+        }
+        return {
+            url,
+            method: 'POST',
+            data,
+            target: {
+                name: UITarget.ActivityLog,
+            },
+        };
+    }
+    function createEntityDataGenerator(context, { entityType, data, }) {
+        const url = `/v1/${ENTITY_PATH_MAP[entityType]}`;
+        const target = entityType === context.type
+            ? {
+                name: UITarget.ListView,
+                data: {
+                    entityType,
+                    entityData: data,
+                },
+            }
+            : null;
+        return {
+            url,
+            method: 'POST',
+            data,
+            target,
+        };
+    }
+    function relateEntityDataGenerator(context, { entityType, entityId, data, }) {
+        const url = `/v1/${ENTITY_PATH_MAP[entityType]}/${entityId}/related`;
+        const isCurrentEntity = entityType === context.type && entityId === context.id;
+        const target = isCurrentEntity
+            ? {
+                name: UITarget.Related,
+                data,
+            }
+            : null;
+        return {
+            url,
+            method: 'POST',
+            data: {
+                resource: data,
+            },
+            target,
+        };
     }
 
-    var Deferred = /** @class */ (function () {
-        function Deferred() {
-            var _this = this;
-            this.resolve = function (value) {
-                _this._resolve(value);
-            };
-            this.reject = function (reason) {
-                _this._reject(reason);
-            };
-            this._promise = new Promise(function (resolve, reject) {
-                _this._resolve = resolve;
-                _this._reject = reject;
-            });
-        }
-        Object.defineProperty(Deferred.prototype, "promise", {
-            get: function () {
-                return this._promise;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        return Deferred;
-    }());
+    class Deferred {
+        static resetNextId() {
+            Deferred._nextId = 0;
+        }
+        static getNextId() {
+            return Deferred._nextId++;
+        }
+        constructor() {
+            this.resolve = (value) => {
+                this._resolve(value);
+            };
+            this.reject = (reason) => {
+                this._reject(reason);
+            };
+            this._promise = new Promise((resolve, reject) => {
+                this._resolve = resolve;
+                this._reject = reject;
+            });
+            this._id = Deferred.getNextId();
+        }
+        get promise() {
+            return this._promise;
+        }
+        get id() {
+            return this._id;
+        }
+    }
+    Deferred._nextId = 0;
 
-    /**
-     * getParameterByName
-     */
-    function getParameterByName(name, url) {
-        if (url === void 0) { url = ''; }
-        if (!url) {
-            url = window.location.href;
-        }
-        name = name.replace(/[[]]/g, '\\$&');
-        var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)');
-        var results = regex.exec(url);
-        if (!results || !results[2]) {
-            return '';
-        }
-        return decodeURIComponent(results[2].replace(/\+/g, ' '));
-    }
-    function log() {
-        var msg = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            msg[_i] = arguments[_i];
-        }
-        console.log.apply(console, msg); // tslint:disable-line
-    }
-    function checkEnvironment() {
-        // when the running environment is node.js, throwing error
-        if (typeof window === 'undefined') {
-            log('Copper can only run in browser environment');
-            return false;
-        }
-        if (window.top === window) {
-            log('Copper should be inside an iframe, otherwise it might not work as expected.');
-        }
-        return true;
-    }
-    /**
-     * This method has side effect,
-     * it will alter the obj passed in
-     */
-    function createArrayWhenEmpty(obj, name) {
-        if (!obj[name]) {
-            obj[name] = [];
-        }
-    }
-    function delayExecution(func, delay) {
-        if (delay === void 0) { delay = 1000; }
-        setTimeout(function () {
-            func();
-        }, delay);
+    /**
+     * getParameterByName
+     */
+    function getParameterByName(name, url = '') {
+        if (!url) {
+            url = window.location.href;
+        }
+        name = name.replace(/[[]]/g, '\\$&');
+        const regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)');
+        const results = regex.exec(url);
+        if (!results || !results[2]) {
+            return '';
+        }
+        return decodeURIComponent(results[2].replace(/\+/g, ' '));
+    }
+    function log(...msg) {
+        console.log(...msg); // tslint:disable-line
+    }
+    function checkEnvironment() {
+        // when the running environment is node.js, throwing error
+        if (typeof window === 'undefined') {
+            log('Copper can only run in browser environment');
+            return false;
+        }
+        if (window.top === window) {
+            log('Copper should be inside an iframe, otherwise it might not work as expected.');
+        }
+        return true;
+    }
+    /**
+     * This method has side effect,
+     * it will alter the obj passed in
+     */
+    function createArrayWhenEmpty(obj, name) {
+        if (!obj[name]) {
+            obj[name] = [];
+        }
+    }
+    function delayExecution(func, delay = 1000) {
+        setTimeout(() => {
+            func();
+        }, delay);
     }
 
-    var EntityModel = /** @class */ (function () {
-        function EntityModel(type, entityData, editableFields, onSave) {
-            if (editableFields === void 0) { editableFields = []; }
-            var propertyDefinitions = this._getEntityDataDefinition(entityData, editableFields);
-            // override the type getter
-            // we don't want type to be enumerable
-            // since we want to be aligned with developer api
-            propertyDefinitions.type = {
-                enumerable: false,
-                writable: false,
-                value: type,
-            };
-            // override _onSave function
-            propertyDefinitions._onSave = {
-                enumerable: false,
-                value: onSave,
-            };
-            Object.defineProperties(this, propertyDefinitions);
-        }
-        EntityModel.prototype.save = function () {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!this._onSave) return [3 /*break*/, 2];
-                            return [4 /*yield*/, this._onSave(this)];
-                        case 1: return [2 /*return*/, _a.sent()];
-                        case 2: return [2 /*return*/, null];
-                    }
-                });
-            });
-        };
-        EntityModel.prototype.toJSON = function () {
-            return JSON.stringify(this.toObject());
-        };
-        EntityModel.prototype.toObject = function () {
-            var _this = this;
-            var obj = {};
-            Object.keys(this).forEach(function (key) {
-                obj[key] = _this[key];
-            });
-            return obj;
-        };
-        EntityModel.prototype._getEntityDataDefinition = function (entityData, editableFields) {
-            if (editableFields === void 0) { editableFields = []; }
-            var propertyDefinitions = {};
-            Object.keys(entityData).forEach(function (key) {
-                if (editableFields.indexOf(key) === -1) {
-                    propertyDefinitions[key] = {
-                        get: function () {
-                            return entityData[key];
-                        },
-                        set: function () {
-                            log("property " + key + " is read only");
-                        },
-                        enumerable: true,
-                    };
-                }
-                else {
-                    propertyDefinitions[key] = {
-                        value: entityData[key],
-                        writable: true,
-                        enumerable: true,
-                    };
-                }
-            });
-            return propertyDefinitions;
-        };
-        return EntityModel;
-    }());
+    class EntityModel {
+        constructor(type, entityData, editableFields = [], onSave) {
+            const propertyDefinitions = this._getEntityDataDefinition(entityData, editableFields);
+            // override the type getter
+            // we don't want type to be enumerable
+            // since we want to be aligned with developer api
+            propertyDefinitions.type = {
+                enumerable: false,
+                writable: false,
+                value: type,
+            };
+            // override _onSave function
+            propertyDefinitions._onSave = {
+                enumerable: false,
+                value: onSave,
+            };
+            Object.defineProperties(this, propertyDefinitions);
+        }
+        save() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this._onSave) {
+                    return yield this._onSave(this);
+                }
+                return null;
+            });
+        }
+        toJSON() {
+            return JSON.stringify(this.toObject());
+        }
+        toObject() {
+            const obj = {};
+            Object.keys(this).forEach((key) => {
+                obj[key] = this[key];
+            });
+            return obj;
+        }
+        _getEntityDataDefinition(entityData, editableFields = []) {
+            const propertyDefinitions = {};
+            Object.keys(entityData).forEach((key) => {
+                if (editableFields.indexOf(key) === -1) {
+                    propertyDefinitions[key] = {
+                        get() {
+                            return entityData[key];
+                        },
+                        set() {
+                            log(`property ${key} is read only`);
+                        },
+                        enumerable: true,
+                    };
+                }
+                else {
+                    propertyDefinitions[key] = {
+                        value: entityData[key],
+                        writable: true,
+                        enumerable: true,
+                    };
+                }
+            });
+            return propertyDefinitions;
+        }
+    }
 
-    var Copper = /** @class */ (function () {
-        /**
-         * Creates an instance of Copper.
-         * @param {*} [_win=window] has to be any type to support testing
-         * @memberof Copper
-         */
-        function Copper(parentOrigin, instanceId, options, _win) {
-            if (_win === void 0) { _win = window; }
-            this.parentOrigin = parentOrigin;
-            this.instanceId = instanceId;
-            this.options = options;
-            this._win = _win;
-            /**
-             * store deferred queues by name
-             */
-            this.deferredQueues = {};
-            /**
-             * store event callbacks by event name
-             */
-            this.events = {};
-            if (!this.parentOrigin || !this.instanceId) {
-                throw new TypeError('parentOrigin or instanceId is empty');
-            }
-            this._listenMessage();
-            // listen to contextUpdated event
-            this._subscribeContextUpdated();
-            // notify parent frame init
-            this._postMessage('init');
-        }
-        Copper.init = function () {
-            var parentOrigin = getParameterByName('origin');
-            var instanceId = getParameterByName('instanceId');
-            var options = {
-                isGlobal: getParameterByName('isGlobal') === '1',
-            };
-            if (!checkEnvironment()) {
-                throw new Error('Environment checking does not pass.');
-            }
-            return new Copper(parentOrigin, instanceId, options);
-        };
-        Object.defineProperty(Copper, "version", {
-            get: function () {
-                return version;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(Copper.prototype, "win", {
-            get: function () {
-                return this._win;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Copper.prototype.getContext = function () {
-            return __awaiter(this, void 0, void 0, function () {
-                var messageData;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, this._deferredPost('getContext')];
-                        case 1:
-                            messageData = _a.sent();
-                            return [2 /*return*/, this._createContextModel(messageData)];
-                    }
-                });
-            });
-        };
-        Copper.prototype.getUserInfo = function () {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this._deferredPost('getUserInfo')];
-                });
-            });
-        };
-        Copper.prototype.getRouteInfo = function () {
-            return __awaiter(this, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, this._deferredPost('getRouteInfo')];
-                });
-            });
-        };
-        Copper.prototype.saveContext = function (context) {
-            return __awaiter(this, void 0, void 0, function () {
-                var messageData;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, this._deferredPost('saveContext', {
-                                data: {
-                                    entityType: context.type,
-                                    entityData: context.toObject(),
-                                },
-                            })];
-                        case 1:
-                            messageData = _a.sent();
-                            return [2 /*return*/, this._createContextModel(messageData)];
-                    }
-                });
-            });
-        };
-        Copper.prototype.setAppUI = function (data) {
-            this._postMessage('setUI', { data: data });
-        };
-        Copper.prototype.showModal = function (params) {
-            if (params === void 0) { params = {}; }
-            this._postMessage('showModal', { params: params });
-        };
-        Copper.prototype.closeModal = function () {
-            this._postMessage('closeModal');
-        };
-        /**
-         * Allows developer to send message to another instance of its app
-         * e.g. Sending data from modal to sidebar, so sidebar can display some data immediately
-         *
-         * @param target another instance/location of the app. '*' means broadcast to all other locations.
-         */
-        Copper.prototype.publishMessage = function (messageType, target, msg) {
-            if (msg === void 0) { msg = {}; }
-            this._postMessage('publishMessage', {
-                target: target,
-                data: {
-                    type: messageType,
-                    msg: msg,
-                },
-            });
-        };
-        Copper.prototype.logActivity = function (activityType, details, activityDate, refreshDelay) {
-            if (refreshDelay === void 0) { refreshDelay = 0; }
-            return __awaiter(this, void 0, void 0, function () {
-                var context, data;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, this._getCachedContext()];
-                        case 1:
-                            context = _a.sent();
-                            data = logActivityDataGenerator(context, {
-                                activityType: activityType,
-                                details: details,
-                                activityDate: activityDate,
-                            });
-                            return [2 /*return*/, this._action(data, refreshDelay)];
-                    }
-                });
-            });
-        };
-        Copper.prototype.createEntity = function (entityType, entityData, refreshDelay) {
-            if (refreshDelay === void 0) { refreshDelay = 0; }
-            return __awaiter(this, void 0, void 0, function () {
-                var context, e_1, apiOptions, url, method, data, target, result;
-                var _this = this;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            _a.trys.push([0, 2, , 3]);
-                            return [4 /*yield*/, this._getCachedContext()];
-                        case 1:
-                            context = _a.sent();
-                            return [3 /*break*/, 3];
-                        case 2:
-                            e_1 = _a.sent();
-                            // we allow create entity be called without actual context
-                            context = {};
-                            return [3 /*break*/, 3];
-                        case 3:
-                            apiOptions = createEntityDataGenerator(context, {
-                                entityType: entityType,
-                                data: entityData,
-                            });
-                            url = apiOptions.url, method = apiOptions.method, data = apiOptions.data, target = apiOptions.target;
-                            return [4 /*yield*/, this.api(url, { method: method, body: JSON.stringify(data) })];
-                        case 4:
-                            result = _a.sent();
-                            if (target && target.data) {
-                                target.data.entityData = result;
-                                delayExecution(function () {
-                                    _this.refreshUI(target);
-                                }, refreshDelay);
-                            }
-                            return [2 /*return*/, result];
-                    }
-                });
-            });
-        };
-        Copper.prototype.relateEntity = function (entityType, entityId, relateData, refreshDelay) {
-            if (refreshDelay === void 0) { refreshDelay = 0; }
-            return __awaiter(this, void 0, void 0, function () {
-                var context, data;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4 /*yield*/, this._getCachedContext()];
-                        case 1:
-                            context = _a.sent();
-                            data = relateEntityDataGenerator(context, {
-                                entityType: entityType,
-                                entityId: parseInt(entityId, 10),
-                                data: relateData,
-                            });
-                            return [2 /*return*/, this._action(data, refreshDelay)];
-                    }
-                });
-            });
-        };
-        Copper.prototype.refreshUI = function (target) {
-            this._postMessage('refreshUI', { target: target });
-        };
-        Copper.prototype.on = function (eventName, cb) {
-            createArrayWhenEmpty(this.events, eventName);
-            this.events[eventName].push(cb);
-        };
-        Copper.prototype.trigger = function (eventName, data) {
-            var _this = this;
-            if (this.events[eventName]) {
-                this.events[eventName].forEach(function (cb) {
-                    cb.call(_this, data);
-                });
-            }
-        };
-        Copper.prototype.api = function (url, options) {
-            if (!url) {
-                return Promise.reject({
-                    id: 'sdk-api',
-                    version: Copper.version,
-                    detail: 'url cannot be empty',
-                });
-            }
-            if (options && options.body) {
-                try {
-                    JSON.parse(options.body);
-                }
-                catch (e) {
-                    return Promise.reject({
-                        id: 'sdk-api',
-                        version: Copper.version,
-                        detail: 'body must be a valid JSON string',
-                    });
-                }
-            }
-            return this._deferredPost('api', {
-                url: url,
-                options: options,
-            });
-        };
-        Copper.prototype.navigateToEntityDetail = function (entityType, entityId) {
-            return this._deferredPost('navigateToEntityDetail', { entityType: entityType, entityId: entityId });
-        };
-        Copper.prototype.getSelectedRecords = function (_a) {
-            var _b = _a === void 0 ? {} : _a, _c = _b.pageSize, pageSize = _c === void 0 ? 100 : _c, _d = _b.pageNumber, pageNumber = _d === void 0 ? 0 : _d;
-            return this._deferredPost('getSelectedRecords', { pageSize: pageSize, pageNumber: pageNumber });
-        };
-        Copper.prototype.getConfig = function () {
-            return this._deferredPost('getConfig');
-        };
-        Copper.prototype._getCachedContext = function () {
-            return __awaiter(this, void 0, void 0, function () {
-                var context;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (this._context) {
-                                return [2 /*return*/, this._context];
-                            }
-                            return [4 /*yield*/, this.getContext()];
-                        case 1:
-                            context = (_a.sent()).context;
-                            return [2 /*return*/, context];
-                    }
-                });
-            });
-        };
-        Copper.prototype._postMessage = function (type, message) {
-            if (message === void 0) { message = {}; }
-            this.win.top.postMessage(__assign(__assign({}, message), { 
-                // as a credential to the parent frame, so parent frame can recoganize the origin
-                instanceId: this.instanceId, 
-                // tell parent frame current sdk version
-                version: version,
-                // type of message
-                type: type }), this.parentOrigin);
-        };
-        Copper.prototype._listenMessage = function () {
-            var _this = this;
-            this.win.addEventListener('message', function (event) {
-                if (!_this._isOriginValid(event)) {
-                    return;
-                }
-                // if type is a deferred type, we resolve it
-                // otherwise we do something else
-                _this._resolveDeferred(event.data.type, event.data);
-                // if event type exists, we pass the event to SDK
-                // so sdk user can subscribe those events
-                if (event.data.type) {
-                    _this.trigger(event.data.type, event.data.msg || event.data.data);
-                }
-            }, false);
-        };
-        Copper.prototype._isOriginValid = function (event) {
-            // only check origin for now
-            return event.origin === this.parentOrigin;
-        };
-        Copper.prototype._enqueueDeferred = function (queueName, deferred) {
-            createArrayWhenEmpty(this.deferredQueues, queueName);
-            this.deferredQueues[queueName].push(deferred);
-        };
-        Copper.prototype._resolveDeferred = function (queueName, data) {
-            if (!this.deferredQueues[queueName]) {
-                return;
-            }
-            var deferred = this.deferredQueues[queueName].shift();
-            if (deferred) {
-                if (data.error) {
-                    return deferred.reject(data.error);
-                }
-                deferred.resolve(data.data);
-            }
-        };
-        Copper.prototype._createContextModel = function (_a) {
-            var entityType = _a.entityType, entityData = _a.entityData, editableFields = _a.editableFields;
-            var context = new EntityModel(entityType, entityData, editableFields, this.saveContext.bind(this));
-            this._context = context;
-            return {
-                type: entityType,
-                context: context,
-            };
-        };
-        Copper.prototype._action = function (_a, delay) {
-            var url = _a.url, method = _a.method, data = _a.data, target = _a.target;
-            return __awaiter(this, void 0, void 0, function () {
-                var result;
-                var _this = this;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0: return [4 /*yield*/, this.api(url, { method: method, body: JSON.stringify(data) })];
-                        case 1:
-                            result = _b.sent();
-                            if (target) {
-                                delayExecution(function () {
-                                    _this.refreshUI(target);
-                                }, delay);
-                            }
-                            return [2 /*return*/, result];
-                    }
-                });
-            });
-        };
-        Copper.prototype._createDeferredMethod = function (queueName, executor) {
-            var deferred = new Deferred();
-            this._enqueueDeferred(queueName, deferred);
-            executor();
-            return deferred.promise;
-        };
-        Copper.prototype._deferredPost = function (name, data) {
-            var _this = this;
-            return this._createDeferredMethod(name, function () {
-                if (data) {
-                    _this._postMessage(name, data);
-                }
-                else {
-                    _this._postMessage(name);
-                }
-            });
-        };
-        Copper.prototype._subscribeContextUpdated = function () {
-            var _this = this;
-            this.on('contextUpdated', function () {
-                // remove _context caching
-                _this._context = null;
-            });
-        };
-        return Copper;
-    }());
+    class Copper {
+        static init() {
+            const parentOrigin = getParameterByName('origin');
+            const instanceId = getParameterByName('instanceId');
+            const options = {
+                isGlobal: getParameterByName('isGlobal') === '1',
+            };
+            if (!checkEnvironment()) {
+                throw new Error('Environment checking does not pass.');
+            }
+            return new Copper(parentOrigin, instanceId, options);
+        }
+        static get version() {
+            return version;
+        }
+        /**
+         * Creates an instance of Copper.
+         * @param {*} [_win=window] has to be any type to support testing
+         * @memberof Copper
+         */
+        constructor(parentOrigin, instanceId, options, _win = window) {
+            this.parentOrigin = parentOrigin;
+            this.instanceId = instanceId;
+            this.options = options;
+            this._win = _win;
+            /**
+             * store deferred queues by name
+             */
+            this.deferredQueues = {};
+            /**
+             * store event callbacks by event name
+             */
+            this.events = {};
+            if (!this.parentOrigin || !this.instanceId) {
+                throw new TypeError('parentOrigin or instanceId is empty');
+            }
+            this._listenMessage();
+            // listen to contextUpdated event
+            this._subscribeContextUpdated();
+            // notify parent frame init
+            this._postMessage('init');
+        }
+        get win() {
+            return this._win;
+        }
+        getContext() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const messageData = yield this._deferredPost('getContext');
+                return this._createContextModel(messageData);
+            });
+        }
+        getUserInfo() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this._deferredPost('getUserInfo');
+            });
+        }
+        getRouteInfo() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this._deferredPost('getRouteInfo');
+            });
+        }
+        saveContext(context) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const messageData = yield this._deferredPost('saveContext', {
+                    data: {
+                        entityType: context.type,
+                        entityData: context.toObject(),
+                    },
+                });
+                return this._createContextModel(messageData);
+            });
+        }
+        setAppUI(data) {
+            this._postMessage('setUI', { data });
+        }
+        showModal(params = {}) {
+            this._postMessage('showModal', { params });
+        }
+        closeModal() {
+            this._postMessage('closeModal');
+        }
+        /**
+         * Allows developer to send message to another instance of its app
+         * e.g. Sending data from modal to sidebar, so sidebar can display some data immediately
+         *
+         * @param target another instance/location of the app. '*' means broadcast to all other locations.
+         */
+        publishMessage(messageType, target, msg = {}) {
+            this._postMessage('publishMessage', {
+                target,
+                data: {
+                    type: messageType,
+                    msg,
+                },
+            });
+        }
+        logActivity(activityType_1, details_1, activityDate_1) {
+            return __awaiter(this, arguments, void 0, function* (activityType, details, activityDate, refreshDelay = 0) {
+                const context = yield this._getCachedContext();
+                const data = logActivityDataGenerator(context, {
+                    activityType,
+                    details,
+                    activityDate,
+                });
+                return this._action(data, refreshDelay);
+            });
+        }
+        createEntity(entityType_1, entityData_1) {
+            return __awaiter(this, arguments, void 0, function* (entityType, entityData, refreshDelay = 0) {
+                let context;
+                try {
+                    context = yield this._getCachedContext();
+                }
+                catch (e) {
+                    // we allow create entity be called without actual context
+                    context = {};
+                }
+                const apiOptions = createEntityDataGenerator(context, {
+                    entityType,
+                    data: entityData,
+                });
+                const { url, method, data, target } = apiOptions;
+                const result = yield this.api(url, { method, body: JSON.stringify(data) });
+                if (target && target.data) {
+                    target.data.entityData = result;
+                    delayExecution(() => {
+                        this.refreshUI(target);
+                    }, refreshDelay);
+                }
+                return result;
+            });
+        }
+        relateEntity(entityType_1, entityId_1, relateData_1) {
+            return __awaiter(this, arguments, void 0, function* (entityType, entityId, relateData, refreshDelay = 0) {
+                const context = yield this._getCachedContext();
+                const data = relateEntityDataGenerator(context, {
+                    entityType,
+                    entityId: parseInt(entityId, 10),
+                    data: relateData,
+                });
+                return this._action(data, refreshDelay);
+            });
+        }
+        refreshUI(target) {
+            this._postMessage('refreshUI', { target });
+        }
+        on(eventName, cb) {
+            createArrayWhenEmpty(this.events, eventName);
+            this.events[eventName].push(cb);
+        }
+        trigger(eventName, data) {
+            if (this.events[eventName]) {
+                this.events[eventName].forEach((cb) => {
+                    cb.call(this, data);
+                });
+            }
+        }
+        api(url, options) {
+            if (!url) {
+                return Promise.reject({
+                    id: 'sdk-api',
+                    version: Copper.version,
+                    detail: 'url cannot be empty',
+                });
+            }
+            if (options && options.body) {
+                try {
+                    JSON.parse(options.body);
+                }
+                catch (e) {
+                    return Promise.reject({
+                        id: 'sdk-api',
+                        version: Copper.version,
+                        detail: 'body must be a valid JSON string',
+                    });
+                }
+            }
+            return this._deferredPost('api', {
+                url,
+                options,
+            });
+        }
+        navigateToEntityDetail(entityType, entityId) {
+            return this._deferredPost('navigateToEntityDetail', { entityType, entityId });
+        }
+        getSelectedRecords({ pageSize = 100, pageNumber = 0 } = {}) {
+            return this._deferredPost('getSelectedRecords', { pageSize, pageNumber });
+        }
+        getConfig() {
+            return this._deferredPost('getConfig');
+        }
+        _getCachedContext() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this._context) {
+                    return this._context;
+                }
+                const { context } = yield this.getContext();
+                return context;
+            });
+        }
+        _postMessage(type, message = {}, id = -1) {
+            var _a;
+            (_a = this.win.top) === null || _a === void 0 ? void 0 : _a.postMessage(Object.assign(Object.assign({}, message), { 
+                // as a credential to the parent frame, so parent frame can recoganize the origin
+                instanceId: this.instanceId, 
+                // tell parent frame current sdk version
+                version,
+                // type of message
+                type,
+                // optional id for message
+                id }), this.parentOrigin);
+        }
+        _listenMessage() {
+            this.win.addEventListener('message', (event) => {
+                if (!this._isOriginValid(event)) {
+                    return;
+                }
+                // if type is a deferred type, we resolve it
+                // otherwise we do something else
+                this._resolveDeferred(event.data.type, event.data.id, event.data);
+                // if event type exists, we pass the event to SDK
+                // so sdk user can subscribe those events
+                if (event.data.type) {
+                    this.trigger(event.data.type, event.data.msg || event.data.data);
+                }
+            }, false);
+        }
+        _isOriginValid(event) {
+            // only check origin for now
+            return event.origin === this.parentOrigin;
+        }
+        _enqueueDeferred(queueName, deferred) {
+            createArrayWhenEmpty(this.deferredQueues, queueName);
+            this.deferredQueues[queueName].push(deferred);
+        }
+        _resolveDeferred(queueName, messageId, data) {
+            const queue = this.deferredQueues[queueName];
+            if (!queue) {
+                return;
+            }
+            const foundIdx = queue.findIndex((d) => {
+                return d.id === messageId;
+            });
+            const deferred = queue[foundIdx];
+            if (deferred) {
+                queue.splice(foundIdx, 1);
+                if (data.error) {
+                    return deferred.reject(data.error);
+                }
+                deferred.resolve(data.data);
+            }
+        }
+        _createContextModel({ entityType, entityData, editableFields, }) {
+            const context = new EntityModel(entityType, entityData, editableFields, this.saveContext.bind(this));
+            this._context = context;
+            return {
+                type: entityType,
+                context,
+            };
+        }
+        _action(_a, delay_1) {
+            return __awaiter(this, arguments, void 0, function* ({ url, method, data, target }, delay) {
+                const result = yield this.api(url, { method, body: JSON.stringify(data) });
+                if (target) {
+                    delayExecution(() => {
+                        this.refreshUI(target);
+                    }, delay);
+                }
+                return result;
+            });
+        }
+        _createDeferredMethod(queueName, executor) {
+            const deferred = new Deferred();
+            this._enqueueDeferred(queueName, deferred);
+            executor(deferred);
+            return deferred.promise;
+        }
+        _deferredPost(name, data) {
+            return this._createDeferredMethod(name, (deferred) => {
+                if (data) {
+                    this._postMessage(name, data, deferred.id);
+                }
+                else {
+                    this._postMessage(name, {}, deferred.id);
+                }
+            });
+        }
+        _subscribeContextUpdated() {
+            this.on('contextUpdated', () => {
+                // remove _context caching
+                this._context = null;
+            });
+        }
+    }
 
     return Copper;
 
-})));
+}));
+//# sourceMappingURL=copper-sdk.js.map