bruce-models 2.5.2 → 2.5.4

package/dist/bruce-models.umd.js

@@ -11339,7 +11339,7 @@
         }
         Plugin.GetList = GetList;
         function GetLoadUrl(params) {
-            let { api, pluginId, req, cacheKey } = params;
+            let { api, pluginId, cacheKey } = params;
             if (!api) {
                 api = exports.ENVIRONMENT.Api().GetBruceApi();
             }
@@ -11351,6 +11351,148 @@
             };
         }
         Plugin.GetLoadUrl = GetLoadUrl;
+        function Update(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { plugin, api, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                if (!plugin.Name || !plugin.ID) {
+                    throw ("Plugin name and ID are required.");
+                }
+                if (!plugin.ID) {
+                    plugin.ID = exports.ObjectUtils.UId();
+                }
+                yield api.POST(`ui.plugin/${plugin.ID}`, plugin, exports.Api.PrepReqParams(req));
+                api.Cache.Remove(GetCacheKey(plugin.ID));
+                api.Cache.Remove(GetListCacheKey());
+            });
+        }
+        Plugin.Update = Update;
+        function Delete(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { pluginId, api, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                if (!pluginId) {
+                    throw ("Plugin ID is required.");
+                }
+                yield api.DELETE(`ui.plugin/${pluginId}`, exports.Api.PrepReqParams(req));
+                api.Cache.Remove(GetCacheKey(pluginId));
+                api.Cache.Remove(GetListCacheKey());
+            });
+        }
+        Plugin.Delete = Delete;
+        /**
+         * Warning: This will replace the contents of your plugin.
+         * Upload only ZIP files.
+         * @param params
+         */
+        function Upload(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { pluginId, api, file, onProgress, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                if (!pluginId || !file) {
+                    throw ("Plugin ID and file are required.");
+                }
+                req = exports.Api.PrepReqParams(req);
+                req.onProgress = (progress) => {
+                    const percent = Math.round((progress.loaded / file.size) * 100);
+                    onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+                        percent: percent,
+                        uploaded: false
+                    });
+                };
+                yield api.UPLOAD(`ui.plugin/${pluginId}/file`, file, req);
+                api.Cache.Remove(GetCacheKey(pluginId));
+                api.Cache.Remove(GetListCacheKey());
+            });
+        }
+        Plugin.Upload = Upload;
+        /**
+         * Returns a run function to call that'll load a plugin within your provided container element.
+         * The run function will return a dispose function to call to remove the plugin.
+         * @param params
+         * @returns
+         */
+        function GetRunFunction(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { containerId, container, pluginParams, pluginId, plugin, api } = params;
+                if (!containerId && container) {
+                    containerId = container.id;
+                    if (!containerId) {
+                        containerId = exports.ObjectUtils.UId();
+                        container.id = containerId;
+                    }
+                }
+                if (!plugin && pluginId) {
+                    plugin = (yield Plugin.Get({
+                        pluginId,
+                        api
+                    })).plugin;
+                }
+                const { indexFileUrl } = GetLoadUrl({
+                    api,
+                    pluginId,
+                    cacheKey: plugin.Version
+                });
+                let fileContent = yield fetch(indexFileUrl).then((res) => res.text());
+                const start = fileContent.indexOf("{");
+                const end = fileContent.lastIndexOf("}");
+                fileContent = fileContent.substring(start + 1, end);
+                const paramsId = exports.ObjectUtils.UId();
+                window[paramsId] = pluginParams ? pluginParams : {};
+                const disposeId = exports.ObjectUtils.UId();
+                let script = `
+            function run() {
+                ${fileContent}
+
+                const paramsId = "${paramsId}";
+                const containerId = "${container.id}";
+                let container;
+                if (containerId) {
+                    container = document.getElementById("${container.id}");
+                }
+                {TEMPLATE_CODE}
+                const params = window["${paramsId}"];
+
+                window["${disposeId}"] = Run({
+                    container,
+                    pluginParams: params
+                });
+            }
+            run();
+        `;
+                if (script.includes("var template")) {
+                    script = script.replace("{TEMPLATE_CODE}", `
+                if (container && template) {
+                    container.innerHTML = template;
+                }
+            `);
+                }
+                else {
+                    script = script.replace("{TEMPLATE_CODE}", "");
+                }
+                return {
+                    run: () => {
+                        const eval2 = eval;
+                        eval2(script);
+                        // Ensure a function is returned, even if the plugin is not configured properly to return one.
+                        if (!window[disposeId] || typeof window[disposeId] !== "function") {
+                            window[disposeId] = () => {
+                                console.warn("Plugin called to be disposed but no dispose function was found.");
+                            };
+                        }
+                        const callDispose = window[disposeId];
+                        return () => callDispose();
+                    }
+                };
+            });
+        }
+        Plugin.GetRunFunction = GetRunFunction;
     })(exports.Plugin || (exports.Plugin = {}));
 
     const VERSION$1 = "2.5.2";