@prisme.ai/sdk 1.0.0 → 1.0.2

package/dist/sdk/lib/endpoints/workspaces.js

@@ -2,6 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var _tslib = require('../../../_virtual/_tslib.js');
+var ImportProcessing = require('../ImportProcessing.js');
+var utils = require('../utils.js');
 var workspacesVersions = require('./workspacesVersions.js');
 
 var WorkspacesEndpoint = /** @class */ (function () {
@@ -16,6 +19,124 @@ var WorkspacesEndpoint = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    WorkspacesEndpoint.prototype.update = function (workspace) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, _c;
+            return _tslib.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = this.api).patch;
+                        _c = ["/workspaces/".concat(this.id)];
+                        return [4 /*yield*/, this.api.replaceAllImagesData(workspace, this.id)];
+                    case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([_d.sent()]))];
+                    case 2: return [2 /*return*/, _d.sent()];
+                }
+            });
+        });
+    };
+    WorkspacesEndpoint.prototype.delete = function () {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.api.delete("/workspaces/".concat(this.id))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    WorkspacesEndpoint.prototype.uploadFiles = function (files, opts) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var formData, e_1;
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        formData = new FormData();
+                        (Array.isArray(files) ? files : [files]).forEach(function (file) {
+                            try {
+                                formData.append.apply(formData, _tslib.__spreadArray(['file'], utils.dataURItoBlob(file), false));
+                            }
+                            catch (_a) { }
+                        });
+                        if (opts === null || opts === void 0 ? void 0 : opts.expiresAfter) {
+                            formData.append('expiresAfter', "".concat(opts === null || opts === void 0 ? void 0 : opts.expiresAfter));
+                        }
+                        if (typeof (opts === null || opts === void 0 ? void 0 : opts.public) === 'boolean') {
+                            formData.append('public', "".concat(opts === null || opts === void 0 ? void 0 : opts.public));
+                        }
+                        if (typeof (opts === null || opts === void 0 ? void 0 : opts.shareToken) === 'boolean') {
+                            formData.append('shareToken', "".concat(opts === null || opts === void 0 ? void 0 : opts.shareToken));
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.api.post("/workspaces/".concat(this.id, "/files"), formData)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3:
+                        e_1 = _a.sent();
+                        console.error(e_1);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/, []];
+                }
+            });
+        });
+    };
+    WorkspacesEndpoint.prototype.listAppInstances = function () {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.api.get("/workspaces/".concat(this.id, "/apps"))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    WorkspacesEndpoint.prototype.getUsage = function (_a) {
+        var _b = _a === void 0 ? {} : _a, afterDate = _b.afterDate, beforeDate = _b.beforeDate, details = _b.details;
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var params;
+            return _tslib.__generator(this, function (_c) {
+                params = new URLSearchParams(utils.removedUndefinedProperties({
+                    afterDate: "".concat(afterDate || ''),
+                    beforeDate: "".concat(beforeDate || ''),
+                    details: "".concat(details || ''),
+                }, true));
+                return [2 /*return*/, this.api.get("/workspaces/".concat(this.id, "/usage?").concat(params.toString()))];
+            });
+        });
+    };
+    WorkspacesEndpoint.prototype.importArchive = function (archive) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return _tslib.__generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve) {
+                        var fileReader = new FileReader();
+                        fileReader.addEventListener('load', function (_a) {
+                            var target = _a.target;
+                            return _tslib.__awaiter(_this, void 0, void 0, function () {
+                                var file, formData, result;
+                                return _tslib.__generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            file = target === null || target === void 0 ? void 0 : target.result;
+                                            formData = new FormData();
+                                            formData.append.apply(formData, _tslib.__spreadArray(['archive'], utils.dataURItoBlob(file), false));
+                                            return [4 /*yield*/, this.api.post("/workspaces/".concat(this.id, "/import"), formData)];
+                                        case 1:
+                                            result = _b.sent();
+                                            if (result.processing) {
+                                                throw new ImportProcessing.ImportProcessingError(result);
+                                            }
+                                            resolve(result);
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            });
+                        });
+                        fileReader.readAsDataURL(archive);
+                    })];
+            });
+        });
+    };
     return WorkspacesEndpoint;
 }());
 

package/dist/sdk/lib/endpoints/workspacesVersions.js

@@ -10,10 +10,10 @@ var WorkspacesVersionsEndpoint = /** @class */ (function () {
         this.api = api;
     }
     WorkspacesVersionsEndpoint.prototype.create = function (version) {
-        this.api.post("/workspaces/".concat(this.workspaceId, "/versions"), version);
+        return this.api.post("/workspaces/".concat(this.workspaceId, "/versions"), version);
     };
-    WorkspacesVersionsEndpoint.prototype.rollback = function (versionId) {
-        this.api.post("/workspaces/".concat(this.workspaceId, "/versions/").concat(versionId, "/rollback"));
+    WorkspacesVersionsEndpoint.prototype.rollback = function (versionId, opts) {
+        return this.api.post("/workspaces/".concat(this.workspaceId, "/versions/").concat(versionId, "/pull"), opts);
     };
     WorkspacesVersionsEndpoint.prototype.export = function (version) {
         if (version === void 0) { version = 'current'; }
@@ -22,7 +22,7 @@ var WorkspacesVersionsEndpoint = /** @class */ (function () {
             return _tslib.__generator(this, function (_b) {
                 switch (_b.label) {
                     case 0: return [4 /*yield*/, this.api.prepareRequest("/workspaces/".concat(this.workspaceId, "/versions/").concat(version, "/export"), {
-                            method: 'post'
+                            method: 'post',
                         })];
                     case 1:
                         res = _b.sent();

package/dist/sdk/lib/events.js

@@ -11,30 +11,59 @@ var io__default = /*#__PURE__*/_interopDefaultLegacy(io);
 
 var Events = /** @class */ (function () {
     function Events(_a) {
-        var workspaceId = _a.workspaceId, token = _a.token, apiKey = _a.apiKey, _b = _a.apiHost, apiHost = _b === void 0 ? 'https://api.eda.prisme.ai' : _b, filters = _a.filters, api = _a.api;
+        var workspaceId = _a.workspaceId, token = _a.token, legacyToken = _a.legacyToken, apiKey = _a.apiKey, _b = _a.apiHost, apiHost = _b === void 0 ? 'https://api.eda.prisme.ai' : _b, filters = _a.filters, api = _a.api, transports = _a.transports;
         var _this = this;
         this.listeners = new Map();
         this.workspaceId = workspaceId;
         var queryString = new URLSearchParams(filters || {}).toString();
         var fullQueryString = queryString ? "?".concat(queryString) : '';
-        var extraHeaders = {
-            'x-prismeai-token': token,
-        };
+        var extraHeaders = token
+            ? {
+                authorization: "Bearer ".concat(token),
+            }
+            : { 'x-prismeai-token': legacyToken };
+        this.lastReceivedEventDate = new Date();
         if (apiKey) {
             extraHeaders['x-prismeai-api-key'] = apiKey;
         }
+        this.filters = [filters || {}];
+        this.listenedUserTopics = new Map();
         this.client = io__default["default"]("".concat(apiHost, "/workspaces/").concat(workspaceId, "/events").concat(fullQueryString), {
             extraHeaders: extraHeaders,
-            withCredentials: true,
+            withCredentials: !extraHeaders.authorization,
+            transports: transports || ['polling', 'websocket'],
+            auth: function (cb) {
+                cb({
+                    // Browser websockets cannot send extraHeaders, so we use socketio-client auth instead
+                    extraHeaders: transports && transports[0] === 'websocket' ? extraHeaders : {},
+                    filters: {
+                        payloadQuery: _this.filters,
+                    },
+                    reuseSocketId: _this.socketId,
+                });
+            },
+        });
+        this.client.on('connect_error', function (err) {
+            console.error("Failed websocket connection : ", err);
+            // revert to classic upgrade
+            _this.client.io.opts.transports = ['polling', 'websocket'];
+        });
+        this.client.on('error', function (err) {
+            _this.client.io.opts.transports = ['polling', 'websocket'];
         });
-        var lastConnectionTime = new Date();
         var onConnect = function () {
+            // First connection
+            if (!_this.socketId) {
+                _this.socketId = _this.client.id;
+                return;
+            }
+            // Retrieve lost history on reconnection
             setTimeout(function () { return _tslib.__awaiter(_this, void 0, void 0, function () {
                 var events;
                 var _this = this;
                 return _tslib.__generator(this, function (_a) {
                     switch (_a.label) {
-                        case 0: return [4 /*yield*/, api.getEvents(workspaceId, _tslib.__assign(_tslib.__assign({}, this.filters[this.filters.length - 1]), { afterDate: lastConnectionTime.toISOString() }))];
+                        case 0: return [4 /*yield*/, api.getEvents(workspaceId, _tslib.__assign(_tslib.__assign({}, this.filters[this.filters.length - 1]), { afterDate: this.lastReceivedEventDate.toISOString() }))];
                         case 1:
                             events = _a.sent();
                             events.reverse().forEach(function (event) {
@@ -47,13 +76,18 @@ var Events = /** @class */ (function () {
                 });
             }); }, 2000);
         };
+        this.client.on('connect', onConnect);
         this.client.on('disconnect', function () {
-            lastConnectionTime = new Date();
+            if (!_this.lastReceivedEventDate) {
+                _this.lastReceivedEventDate = new Date();
+            }
+            // Make sure we reconnect with current filters & socketId
+            _this.client.auth = _tslib.__assign(_tslib.__assign({}, _this.client.auth), { filters: {
+                    payloadQuery: _this.filters,
+                }, reuseSocketId: _this.socketId });
             _this.client.off('connect', onConnect);
             _this.client.on('connect', onConnect);
         });
-        this.filters = [filters || {}];
-        this.listenedUserTopics = new Map();
     }
     Object.defineProperty(Events.prototype, "socket", {
         get: function () {
@@ -75,12 +109,16 @@ var Events = /** @class */ (function () {
     };
     Events.prototype.all = function (listener) {
         var _this = this;
-        this.client.onAny(listener);
-        return function () { return _this.client.offAny(listener); };
+        var anyListener = function (eventName, eventData) {
+            _this.lastReceivedEventDate = new Date(eventData === null || eventData === void 0 ? void 0 : eventData.createdAt);
+            return listener(eventName, eventData);
+        };
+        this.client.onAny(anyListener);
+        return function () { return _this.client.offAny(anyListener); };
     };
     Events.prototype.on = function (ev, listener) {
         var _this = this;
-        this.listeners.set(ev, _tslib.__spreadArray(_tslib.__spreadArray([], (this.listeners.get(ev) || []), true), [listener]));
+        this.listeners.set(ev, _tslib.__spreadArray(_tslib.__spreadArray([], (this.listeners.get(ev) || []), true), [listener], false));
         this.client.on(ev, listener);
         return function () {
             _this.listeners.set(ev, (_this.listeners.get(ev) || []).filter(function (l) { return l !== listener; }));

package/dist/sdk/lib/fetch.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fetch = global.fetch;
+console.log(fetch);
+// @ts-ignore
+delete global.fetch;
+// @ts-ignore
+delete global.XMLHttpRequest;
+
+exports["default"] = fetch;

package/dist/sdk/lib/fetcher.js

@@ -3,8 +3,14 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../../_virtual/_tslib.js');
+var FormData = require('form-data');
 var ApiError = require('./ApiError.js');
 var HTTPError = require('./HTTPError.js');
+var utils = require('./utils.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var FormData__default = /*#__PURE__*/_interopDefaultLegacy(FormData);
 
 var headersAsObject = function (headers) {
     return Array.from(headers).reduce(function (prev, _a) {
@@ -13,11 +19,18 @@ var headersAsObject = function (headers) {
         return (_tslib.__assign(_tslib.__assign({}, prev), (_b = {}, _b[k] = v, _b)));
     }, {});
 };
+function isFormData(data) {
+    return !!(data.append && typeof data.append === 'function');
+}
+var CSRF_TOKEN_HEADER = 'x-prismeai-csrf-token';
 var Fetcher = /** @class */ (function () {
-    function Fetcher(host) {
+    function Fetcher(host, clientIdHeader) {
         this.token = null;
+        this.legacyToken = null;
         this._apiKey = null;
+        this._csrfToken = null;
         this.host = host;
+        this.clientIdHeader = clientIdHeader;
     }
     Object.defineProperty(Fetcher.prototype, "apiKey", {
         set: function (apiKey) {
@@ -29,55 +42,99 @@ var Fetcher = /** @class */ (function () {
     Fetcher.prototype.prepareRequest = function (url, options) {
         if (options === void 0) { options = {}; }
         var headers = new Headers(options.headers || {});
-        if (this.token && !headers.has('x-prismeai-token')) {
-            headers.append('x-prismeai-token', this.token);
+        if (this.token && !headers.has('Authorization')) {
+            headers.append('Authorization', "Bearer ".concat(this.token));
+        }
+        else if (this.legacyToken && !headers.has('Authorization')) {
+            headers.append('x-prismeai-token', this.legacyToken);
         }
         if (this._apiKey && !headers.has('x-prismeai-apikey')) {
             headers.append('x-prismeai-api-key', this._apiKey);
         }
+        if (this._csrfToken && options.method && options.method !== 'GET') {
+            headers.append(CSRF_TOKEN_HEADER, this._csrfToken);
+        }
         if (this.language) {
             headers.append('accept-language', this.language);
         }
-        if ((!options.body || !(options.body instanceof FormData)) &&
+        if (options.body instanceof URLSearchParams) {
+            headers.set('Content-Type', 'application/x-www-form-urlencoded');
+        }
+        if ((!options.body || !(options.body instanceof FormData__default["default"])) &&
             !headers.has('Content-Type')) {
             headers.append('Content-Type', 'application/json');
         }
-        headers.append('Access-Control-Allow-Origin', '*');
-        return global.fetch("".concat(this.host).concat(url), _tslib.__assign(_tslib.__assign({}, options), { headers: headers }));
+        var fullUrl = url.startsWith('http://') || url.startsWith('https://')
+            ? url
+            : "".concat(this.host).concat(url);
+        return global.fetch(fullUrl, _tslib.__assign(_tslib.__assign({ credentials: headers.has('Authorization') ? 'omit' : 'include' }, options), { headers: headers }));
     };
-    Fetcher.prototype._fetch = function (url, options) {
+    Fetcher.prototype._fetch = function (url, options, maxRetries) {
+        var _a;
         if (options === void 0) { options = {}; }
+        if (maxRetries === void 0) { maxRetries = 3; }
         return _tslib.__awaiter(this, void 0, void 0, function () {
-            var res, error, _a, contentType, response, text;
-            return _tslib.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.prepareRequest(url, options)];
+            var res, e_1, error, _b, contentType, response, text;
+            return _tslib.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 2, , 5]);
+                        return [4 /*yield*/, this.prepareRequest(url, options)];
                     case 1:
-                        res = _b.sent();
-                        if (!!res.ok) return [3 /*break*/, 6];
-                        error = void 0;
-                        _b.label = 2;
+                        res = _c.sent();
+                        return [3 /*break*/, 5];
                     case 2:
-                        _b.trys.push([2, 4, , 5]);
-                        _a = ApiError.ApiError.bind;
-                        return [4 /*yield*/, res.json()];
+                        e_1 = _c.sent();
+                        if (!(maxRetries > 0 && e_1.message === 'Load failed')) return [3 /*break*/, 4];
+                        return [4 /*yield*/, utils.wait(20)];
                     case 3:
-                        error = new (_a.apply(ApiError.ApiError, [void 0, _b.sent(), res.status]))();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        _b.sent();
-                        error = new HTTPError.HTTPError(res.statusText, res.status);
-                        return [3 /*break*/, 5];
-                    case 5: throw error;
+                        _c.sent();
+                        return [2 /*return*/, this._fetch(url, options, --maxRetries)];
+                    case 4: throw e_1;
+                    case 5:
+                        if (options.redirect === 'manual' && res.status === 0) {
+                            return [2 /*return*/, { redirected: true }];
+                        }
+                        this.lastReceivedHeaders = headersAsObject(res.headers);
+                        if (this.clientIdHeader && this.lastReceivedHeaders[this.clientIdHeader]) {
+                            this.overwriteClientId = this.lastReceivedHeaders[this.clientIdHeader];
+                        }
+                        if (this.lastReceivedHeaders[CSRF_TOKEN_HEADER]) {
+                            this._csrfToken = this.lastReceivedHeaders[CSRF_TOKEN_HEADER];
+                        }
+                        if (!!res.ok) return [3 /*break*/, 12];
+                        if (!(((_a = res.statusText) === null || _a === void 0 ? void 0 : _a.length) &&
+                            res.statusText.includes('ECONNRESET') &&
+                            maxRetries > 0)) return [3 /*break*/, 7];
+                        console.log("Retrying request towards ".concat(url, " as we received ECONNRESET error : ").concat(res.statusText));
+                        return [4 /*yield*/, utils.wait(20)];
                     case 6:
-                        contentType = res.headers.get('content-type');
-                        if (!(contentType && contentType.includes('application/json'))) return [3 /*break*/, 10];
-                        _b.label = 7;
+                        _c.sent();
+                        return [2 /*return*/, this._fetch(url, options, --maxRetries)];
                     case 7:
-                        _b.trys.push([7, 9, , 10]);
-                        return [4 /*yield*/, res.json()];
+                        error = void 0;
+                        _c.label = 8;
                     case 8:
-                        response = (_b.sent()) || {};
+                        _c.trys.push([8, 10, , 11]);
+                        _b = ApiError.ApiError.bind;
+                        return [4 /*yield*/, res.json()];
+                    case 9:
+                        error = new (_b.apply(ApiError.ApiError, [void 0, _c.sent(), res.status]))();
+                        return [3 /*break*/, 11];
+                    case 10:
+                        _c.sent();
+                        error = new HTTPError.HTTPError(res.statusText, res.status);
+                        return [3 /*break*/, 11];
+                    case 11: throw error;
+                    case 12:
+                        contentType = res.headers.get('content-type');
+                        if (!(contentType && contentType.includes('application/json'))) return [3 /*break*/, 16];
+                        _c.label = 13;
+                    case 13:
+                        _c.trys.push([13, 15, , 16]);
+                        return [4 /*yield*/, res.json()];
+                    case 14:
+                        response = (_c.sent()) || {};
                         Object.defineProperty(response, 'headers', {
                             value: headersAsObject(res.headers),
                             configurable: false,
@@ -85,16 +142,16 @@ var Fetcher = /** @class */ (function () {
                             writable: false,
                         });
                         return [2 /*return*/, response];
-                    case 9:
-                        _b.sent();
+                    case 15:
+                        _c.sent();
                         return [2 /*return*/, {}];
-                    case 10: return [4 /*yield*/, res.text()];
-                    case 11:
-                        text = _b.sent();
+                    case 16: return [4 /*yield*/, res.text()];
+                    case 17:
+                        text = _c.sent();
                         try {
                             return [2 /*return*/, JSON.parse(text)];
                         }
-                        catch (_c) {
+                        catch (_d) {
                             return [2 /*return*/, text];
                         }
                         return [2 /*return*/];
@@ -111,13 +168,12 @@ var Fetcher = /** @class */ (function () {
             });
         });
     };
-    Fetcher.prototype.post = function (url, body) {
+    Fetcher.prototype.post = function (url, body, opts) {
         return _tslib.__awaiter(this, void 0, void 0, function () {
             return _tslib.__generator(this, function (_a) {
-                return [2 /*return*/, this._fetch(url, {
-                        method: 'POST',
-                        body: body && !(body instanceof FormData) ? JSON.stringify(body) : body,
-                    })];
+                return [2 /*return*/, this._fetch(url, _tslib.__assign({ method: 'POST', body: body && !isFormData(body) && !(body instanceof URLSearchParams)
+                            ? JSON.stringify(body)
+                            : body }, opts))];
             });
         });
     };

package/dist/sdk/lib/interpolate.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.js');
+
+function interpolateString(str, values) {
+    if (values === void 0) { values = {}; }
+    return str.replace(/\$\{([^}]+)\}/g, function (_, m) { return values[m] || ''; });
+}
+function interpolate(into, values) {
+    if (typeof into === 'string') {
+        return interpolateString(into, values);
+    }
+    var isArray = Array.isArray(into);
+    var newObject = isArray ? _tslib.__spreadArray([], into) : _tslib.__assign({}, into);
+    for (var _i = 0, _a = Object.keys(newObject); _i < _a.length; _i++) {
+        var key = _a[_i];
+        var value = newObject[key];
+        newObject[key] = interpolate(value, values);
+    }
+    return newObject;
+}
+
+exports.interpolate = interpolate;
+exports.interpolateString = interpolateString;

package/dist/sdk/lib/interpolateVars.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.js');
+
+function interpolateString(str, values) {
+    if (values === void 0) { values = {}; }
+    return str.replace(/\$\{([^}]+)\}/g, function (_, m) { return values[m] || ''; });
+}
+function interpolate(into, values) {
+    if (typeof into === 'string') {
+        return interpolateString(into, values);
+    }
+    var isArray = Array.isArray(into);
+    var newObject = isArray ? _tslib.__spreadArray([], into) : _tslib.__assign({}, into);
+    for (var _i = 0, _a = Object.keys(newObject); _i < _a.length; _i++) {
+        var key = _a[_i];
+        var value = newObject[key];
+        newObject[key] = interpolate(value, values);
+    }
+    return newObject;
+}
+
+exports.interpolate = interpolate;
+exports.interpolateString = interpolateString;

package/dist/sdk/lib/utils.js

@@ -2,6 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var _tslib = require('../../_virtual/_tslib.js');
+
 var removedUndefinedProperties = function (obj, removeEmptyStrings) {
     if (removeEmptyStrings === void 0) { removeEmptyStrings = false; }
     return Object.entries(obj).reduce(function (newObject, _a) {
@@ -13,6 +15,51 @@ var removedUndefinedProperties = function (obj, removeEmptyStrings) {
         }
         return newObject;
     }, {});
-};
+};
+function dataURItoBlob(dataURI) {
+    // convert base64/URLEncoded data component to raw binary data held in a string
+    var byteString;
+    if (dataURI.split(',')[0].indexOf('base64') >= 0)
+        byteString = atob(dataURI.split(',')[1].split(';')[0]);
+    else
+        byteString = unescape(dataURI.split(',')[1]);
+    // separate out the mime component
+    var metadata = dataURI
+        .split(';')
+        .map(function (v) { return v.split(/:/); })
+        .filter(function (pair) { return pair.length === 2; });
+    var _a = metadata.find(function (_a) {
+        var k = _a[0]; _a[1];
+        return k === 'data';
+    }) || [], _b = _a[1], mimeString = _b === void 0 ? '' : _b;
+    var _c = mimeString.split(/\//), ext = _c[1];
+    var _d = metadata.find(function (_a) {
+        var k = _a[0]; _a[1];
+        return k === 'filename';
+    }) || [], _e = _d[1], fileName = _e === void 0 ? "file.".concat(ext) : _e;
+    var sanitizedFileName = encodeURIComponent(decodeURIComponent(fileName).replace(/[;,\s]/g, '-'));
+    // write the bytes of the string to a typed array
+    var ia = new Uint8Array(byteString.length);
+    for (var i = 0; i < byteString.length; i++) {
+        ia[i] = byteString.charCodeAt(i);
+    }
+    return [new Blob([ia], { type: mimeString }), sanitizedFileName];
+}
+function isDataURL(file) {
+    return !!(typeof file === 'string' && file.match(/^data\:/));
+}
+function wait(delay) {
+    if (delay === void 0) { delay = 0; }
+    return _tslib.__awaiter(this, void 0, void 0, function () {
+        return _tslib.__generator(this, function (_a) {
+            return [2 /*return*/, new Promise(function (resolve) {
+                    setTimeout(resolve, delay);
+                })];
+        });
+    });
+}
 
+exports.dataURItoBlob = dataURItoBlob;
+exports.isDataURL = isDataURL;
 exports.removedUndefinedProperties = removedUndefinedProperties;
+exports.wait = wait;

package/lib/ImportProcessing.ts

@@ -0,0 +1,22 @@
+export type ImportProcessing = {
+  processing?: boolean;
+  message?: string;
+};
+export class ImportProcessingError extends Error {
+  error: ImportProcessing;
+  constructor(error: ImportProcessing) {
+    super();
+    this.error = error;
+  }
+}
+export type ImportSuccess = {
+  createdWorkspaceIds?: string[];
+  updatedWorkspaceIds?: string[];
+  imported: string[];
+  errors?: {
+    [name: string]: any;
+  }[];
+  workspace?: Prismeai.DSULReadOnly;
+  publishedApps?: Prismeai.App[];
+  deleted?: string[];
+};