copper-sdk 0.7.0 → 0.8.0

package/es/copper-sdk.js

@@ -1,4 +1,4 @@
-/*! *****************************************************************************
+/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -12,17 +12,8 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 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); }); }
@@ -34,630 +25,520 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-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;
+        });
+    }
+}
 
-export default Copper;
+export { Copper as default };
+//# sourceMappingURL=copper-sdk.js.map