@sankhyalabs/sankhyablocks 1.3.34 → 1.4.0-beta.10

package/dist/components/snk-taskbar.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface SnkTaskbar extends Components.SnkTaskbar, HTMLElement {}
+export const SnkTaskbar: {
+  prototype: SnkTaskbar;
+  new (): SnkTaskbar;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/snk-taskbar.js

@@ -0,0 +1,6 @@
+import { S as SnkTaskbar$1, d as defineCustomElement$1 } from './snk-taskbar2.js';
+
+const SnkTaskbar = SnkTaskbar$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { SnkTaskbar, defineCustomElement };

package/dist/components/snk-taskbar2.js

@@ -0,0 +1,282 @@
+import { h, proxyCustomElement, HTMLElement, createEvent, Host } from '@stencil/core/internal/client';
+import { ApplicationContext } from '@sankhyalabs/core';
+import { d as defineCustomElement$2 } from './snk-config-modal2.js';
+import { d as defineCustomElement$1 } from './snk-configurator2.js';
+
+var TaskbarElement;
+(function (TaskbarElement) {
+  TaskbarElement["PREVIOUS"] = "PREVIOUS";
+  TaskbarElement["NEXT"] = "NEXT";
+  TaskbarElement["REFRESH"] = "REFRESH";
+  TaskbarElement["UPDATE"] = "UPDATE";
+  TaskbarElement["CLONE"] = "CLONE";
+  TaskbarElement["REMOVE"] = "REMOVE";
+  TaskbarElement["INSERT"] = "INSERT";
+  TaskbarElement["CANCEL"] = "CANCEL";
+  TaskbarElement["SAVE"] = "SAVE";
+  TaskbarElement["GRID_MODE"] = "GRID_MODE";
+  TaskbarElement["FORM_MODE"] = "FORM_MODE";
+  TaskbarElement["MORE_OPTIONS"] = "MORE_OPTIONS";
+  TaskbarElement["DIVIDER"] = "DIVIDER";
+  TaskbarElement["CONFIGURATOR"] = "CONFIGURATOR";
+})(TaskbarElement || (TaskbarElement = {}));
+var AuthorizationElements;
+(function (AuthorizationElements) {
+  AuthorizationElements["UPDATE"] = "UPDATE";
+  AuthorizationElements["CLONE"] = "CLONE";
+  AuthorizationElements["REMOVE"] = "REMOVE";
+  AuthorizationElements["INSERT"] = "INSERT";
+  AuthorizationElements["CONFIGURATOR"] = "CONFIGURATOR";
+})(AuthorizationElements || (AuthorizationElements = {}));
+var VisibleWhenForbidden;
+(function (VisibleWhenForbidden) {
+  VisibleWhenForbidden["CONFIG_GRID"] = "CONFIG_GRID";
+  VisibleWhenForbidden["CONFIGURATOR"] = "CONFIGURATOR";
+})(VisibleWhenForbidden || (VisibleWhenForbidden = {}));
+const buildCustomButton = (def, className, action, isEnabled) => {
+  const { hint, text, iconName } = def;
+  if (iconName) {
+    if (text) {
+      return iconTextButton(iconName, def.name, className, hint, text, action, isEnabled);
+    }
+    else {
+      return iconButton(iconName, def.name, className, hint, action, isEnabled);
+    }
+  }
+  else {
+    return textButton(def.name, className, text, hint, action, isEnabled);
+  }
+};
+const buildElem = (element, className, getTitle, action, isEnabled, actions, configName) => {
+  const title = getTitle(element);
+  switch (element) {
+    case TaskbarElement.PREVIOUS:
+      return iconButton("chevron-left", element, className, title, action, isEnabled);
+    case TaskbarElement.NEXT:
+      return iconButton("chevron-right", element, className, title, action, isEnabled);
+    case TaskbarElement.REFRESH:
+      return iconButton("sync", element, className, title, action, isEnabled);
+    case TaskbarElement.UPDATE:
+      return iconButton("edit", element, className, title, action, isEnabled);
+    case TaskbarElement.CLONE:
+      return iconButton("copy", element, className, title, action, isEnabled);
+    case TaskbarElement.REMOVE:
+      return iconButton("delete", element, className, title, action, isEnabled);
+    case TaskbarElement.INSERT:
+      return iconTextButton("plus", element, className, title, title, action, isEnabled);
+    case TaskbarElement.CANCEL:
+      return textButton(element, className, title, title, action, isEnabled);
+    case TaskbarElement.SAVE:
+      return iconTextButton("save", element, className, title, title, action, isEnabled);
+    case TaskbarElement.GRID_MODE:
+      return iconButton("table", element, className, title, action, isEnabled);
+    case TaskbarElement.FORM_MODE:
+      return iconButton("list", element, className, title, action, isEnabled);
+    case TaskbarElement.CONFIGURATOR:
+      return configButton(element, className, getTitle, action, isEnabled, configName);
+    case TaskbarElement.MORE_OPTIONS:
+      return actions && actions.length > 0 ? h("ez-actions-button", { title: title, size: "small", class: className, enabled: isEnabled(element), onEzAction: (evt) => action(evt.detail.value), actions: actions }) : undefined;
+    case TaskbarElement.DIVIDER:
+      return h("hr", { class: "ez-divider-vertical ez-divider--dark ez-margin-horizontal--medium" });
+  }
+};
+function textButton(name, className, text, title, action, isEnabled) {
+  return h("ez-button", { title: title, label: text, size: "small", class: className, enabled: isEnabled(name), onClick: () => action(name) });
+}
+function iconButton(iconName, name, className, title, action, isEnabled) {
+  return h("ez-button", { name: iconName, title: title, mode: "icon", size: "small", class: className, iconName: iconName, enabled: isEnabled(name), onClick: () => action(name) });
+}
+function iconTextButton(iconName, name, className, text, title, action, isEnabled) {
+  return h("ez-button", { name: iconName, title: title, label: text, size: "small", class: className, enabled: isEnabled(name), onClick: () => action(name) },
+    h("ez-icon", { class: "ez-padding-right--small", slot: "leftIcon", iconName: iconName }));
+}
+function configButton(element, className, getTitle, action, isEnabled, configName) {
+  return h("snk-configurator", { key: "configurator", configName: configName, title: getTitle(element), class: className, enabled: isEnabled(element), onChangeViewMode: (evt) => action(evt === null || evt === void 0 ? void 0 : evt.detail) });
+}
+
+const snkTaskbarCss = ".sc-snk-taskbar-h{display:flex}";
+
+const SnkTaskbar = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.actionClick = createEvent(this, "actionClick", 7);
+    this.actionChange = createEvent(this, "actionChange", 7);
+    this._titleKeyByElement = {
+      [TaskbarElement.UPDATE]: "snkTaskbar.titleUpdate",
+      [TaskbarElement.PREVIOUS]: "snkTaskbar.titlePrevious",
+      [TaskbarElement.NEXT]: "snkTaskbar.titleNext",
+      [TaskbarElement.REFRESH]: "snkTaskbar.titleRefresh",
+      [TaskbarElement.CLONE]: "snkTaskbar.titleClone",
+      [TaskbarElement.REMOVE]: "snkTaskbar.titleRemove",
+      [TaskbarElement.MORE_OPTIONS]: "snkTaskbar.titleMoreOptions",
+      [TaskbarElement.INSERT]: "snkTaskbar.titleInsert",
+      [TaskbarElement.CANCEL]: "snkTaskbar.titleCancel",
+      [TaskbarElement.SAVE]: "snkTaskbar.titleSave",
+      [TaskbarElement.GRID_MODE]: "snkTaskbar.titleGridMode",
+      [TaskbarElement.FORM_MODE]: "snkTaskbar.titleFormMode",
+      [TaskbarElement.CONFIGURATOR]: "snkTaskbar.titleConfigurator"
+    };
+  }
+  observeButtons() {
+    this._definitions = undefined;
+  }
+  // Internal methods
+  elementsFromString(strButtons) {
+    const elements = [];
+    if (strButtons) {
+      strButtons.split(",").forEach(buttonName => {
+        buttonName = buttonName.trim();
+        if (VisibleWhenForbidden[buttonName] || this.isAllowed(buttonName)) {
+          elements.push(buttonName.trim());
+        }
+      });
+    }
+    return elements;
+  }
+  isAllowed(buttonName) {
+    if (AuthorizationElements[buttonName]) {
+      return this._permissions ? this._permissions.isSup || this._permissions[buttonName] : false;
+    }
+    return true;
+  }
+  /**
+   * Conforme mecanismo de mensagens, é possível customizar as mensagens dos blocos de construção
+   * através de um pequeno modulo na estrutura da aplicação:
+   * - Criar um arquivo no seguinte caminho: /messages/appmessages.msg.js.
+   * Para conhecer os detalhes do módulo, vide o arquivo neste projeto "/src/lib/message/resources/snk-taskbar.msg.ts"
+   */
+  getTitle(element) {
+    let key;
+    if (this.isAllowed(element)) {
+      key = this._titleKeyByElement[element];
+    }
+    else {
+      key = "snkTaskbar.forbidden";
+    }
+    return key ? this._application.messagesBuilder.getMessage(key, {}) : "";
+  }
+  elementClick(elem) {
+    if (this.dataUnit) {
+      switch (elem) {
+        case TaskbarElement.PREVIOUS:
+          this.dataUnit.previousRecord();
+          break;
+        case TaskbarElement.NEXT:
+          this.dataUnit.nextRecord();
+          break;
+        case TaskbarElement.REFRESH:
+          this.dataUnit.loadData();
+          break;
+        case TaskbarElement.CLONE:
+          this.dataUnit.copySelected();
+          break;
+        case TaskbarElement.REMOVE:
+          this.dataUnit.removeSelectedRecords();
+          break;
+        case TaskbarElement.INSERT:
+          this.dataUnit.addRecord();
+          break;
+        case TaskbarElement.CANCEL:
+          this.dataUnit.cancelEdition();
+          break;
+        case TaskbarElement.SAVE:
+          this.dataUnit.saveData();
+          break;
+      }
+    }
+    this.actionClick.emit(elem);
+  }
+  isEnabled(elem) {
+    if (!this.isAllowed(elem)) {
+      return false;
+    }
+    return !(this.disabledButtons && this.disabledButtons.includes(elem));
+  }
+  getElement(index, def) {
+    let className = def === this.primaryButton ? "ez-button--primary " : "";
+    if (index > 1) {
+      className += "ez-padding-left--medium";
+    }
+    if (TaskbarElement[def.toString()]) {
+      return buildElem(def, className, elem => this.getTitle(elem), elem => this.elementClick(elem), elem => this.isEnabled(elem), this.actionsList, this.configName);
+    }
+    else {
+      return buildCustomButton(def, className, elem => this.elementClick(elem), elem => this.isEnabled(elem));
+    }
+  }
+  // Lifecycle
+  componentWillLoad() {
+    this._application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+    if (this._application) {
+      this._application.getAllAccess().then(access => this._permissions = access);
+    }
+    else {
+      this._permissions = {};
+    }
+  }
+  componentWillRender() {
+    if (this._definitions == undefined && this._permissions) {
+      this._definitions = this.elementsFromString(this.buttons);
+    }
+  }
+  render() {
+    if (this._definitions === undefined) {
+      return undefined;
+    }
+    let index = 0;
+    return (h(Host, null, this._definitions.map((elem) => {
+      if (elem === TaskbarElement.DIVIDER) {
+        index = 0;
+      }
+      else {
+        index++;
+      }
+      if (TaskbarElement[elem]) {
+        return this.getElement(index, TaskbarElement[elem]);
+      }
+      if (this.customButtons.has(elem)) {
+        return this.getElement(index, this.customButtons.get(elem));
+      }
+      return h("slot", { name: elem });
+    })));
+  }
+  static get watchers() { return {
+    "buttons": ["observeButtons"]
+  }; }
+  static get style() { return snkTaskbarCss; }
+}, [6, "snk-taskbar", {
+    "configName": [1, "config-name"],
+    "buttons": [1],
+    "customButtons": [16],
+    "actionsList": [16],
+    "primaryButton": [1, "primary-button"],
+    "disabledButtons": [16],
+    "dataUnit": [16],
+    "_permissions": [32]
+  }]);
+function defineCustomElement() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["snk-taskbar", "snk-config-modal", "snk-configurator"];
+  components.forEach(tagName => { switch (tagName) {
+    case "snk-taskbar":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, SnkTaskbar);
+      }
+      break;
+    case "snk-config-modal":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$2();
+      }
+      break;
+    case "snk-configurator":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$1();
+      }
+      break;
+  } });
+}
+
+export { SnkTaskbar as S, TaskbarElement as T, defineCustomElement as d };

package/dist/components/taskbar-processor.js

@@ -0,0 +1,45 @@
+class TaskbarProcessor {
+  constructor(defaultButtons) {
+    this._defaultButtons = defaultButtons;
+  }
+  process(taskbarId, taskbarManager, dataState, disabledButtons = []) {
+    var _a;
+    this.customButtons = new Map();
+    this.buttons = "";
+    this.disabledButtons = [];
+    (_a = this.getButtonsArray(taskbarId, taskbarManager, dataState)) === null || _a === void 0 ? void 0 : _a.forEach(btnDef => {
+      let buttonName;
+      if (typeof btnDef === "string") {
+        buttonName = btnDef;
+      }
+      else {
+        const customBtn = btnDef;
+        this.customButtons.set(customBtn.name, customBtn);
+        buttonName = customBtn.name;
+      }
+      if (!this.isEnabled(taskbarId, taskbarManager, buttonName, dataState, disabledButtons)) {
+        this.disabledButtons.push(buttonName);
+      }
+      if (this.buttons.length > 0) {
+        this.buttons += ",";
+      }
+      this.buttons += buttonName;
+    });
+  }
+  getButtonsArray(taskbarId, taskbarManager, dataState) {
+    const defaults = this._defaultButtons[taskbarId];
+    if (taskbarManager) {
+      return taskbarManager.getButtons(taskbarId, dataState, [...defaults]);
+    }
+    return defaults;
+  }
+  isEnabled(taskbarId, taskbarManager, buttonName, dataState, disabled) {
+    const originalValue = disabled.includes(buttonName) ? false : true;
+    if (taskbarManager && taskbarManager.isEnabled) {
+      return taskbarManager.isEnabled(taskbarId, dataState, buttonName, originalValue);
+    }
+    return originalValue;
+  }
+}
+
+export { TaskbarProcessor as T };

package/dist/esm/SnkMessageBuilder-5792c260.js

@@ -0,0 +1,280 @@
+const snkDataUnitMessages = {
+  saveInfo: {
+    clone: "Duplicação realizada!",
+    insert: "Inclusão realizada!",
+    update: "Aleração realizada!"
+  },
+  cancelInfo: {
+    clone: "Duplicação descartada!",
+    insert: "A inclusão descartada!",
+    update: "A edição foi descartada!"
+  },
+  removeInfo: "Registro removido com sucesso!",
+  cancelConfirmationTitle: "Aviso",
+  cancelConfirmation: "As alterações realizadas serão descartadas<br/><br/><b>Você realmente gostaria de cancelar?",
+  removeConfirmationTitle: "Excluir",
+  removeConfirmation: "Deseja realmente excluir o registro atual?",
+  forbidden: "Sem permissão",
+  forbiddenUpdate: "Não é possível fazer alterações. Verifique as permissões de acesso.",
+  forbiddenInsert: "Não é possível incluir. Verifique as permissões de acesso.",
+  forbiddenClone: "Não é possível duplicar. Verifique as permissões de acesso.",
+  forbiddenRemove: "Não é possível remover. Verifique as permissões de acesso."
+};
+
+const snkFilterBarMessages = {
+  "addFilter": "Adicionar filtro",
+  "pinFilter": "Fixar filtro",
+  "unpinFilter": "Desfixar filtro",
+  "removeFilter": "Remover filtro",
+  "cleanFilter": "Limpar",
+  "applyFilter": "Aplicar",
+  "findFilter": "Buscar filtros...",
+  "findField": "Buscar filtros...",
+  "modalFindFilter": "Buscar filtro",
+  "emptyFiltersList": "Não há filtros disponíveis",
+  "emptyAppliedFiltersList": "Não há filtros aplicados",
+  "customFilter": "Filtro personalizado",
+  "defaultFilter": "Filtro padrão",
+  "failToLoadConfig": "Falha ao buscar configuração de filtros",
+  "clearAllFilters": "Limpar todos os filtros",
+  "successfullyCleaned": "Filtro limpo com sucesso!",
+  "activeFilter": "{{ACTIVE_FILTERS}} filtro aplicado",
+  "activeFilters": "{{ACTIVE_FILTERS}} filtros aplicados",
+  "noActiveFilters": "Nenhum filtro aplicado",
+  "modalDefaultFilterTitle": "Filtro padrão",
+  "modalInfoTextEditDefault": "Use o layout antigo para editar o seu filtro padrão, em breve traremos uma nova experiência.",
+  "modalInfoTextCreateDefault": "Use o layout antigo para criar o seu filtro padrão, em breve traremos uma nova experiência.",
+  "modalPersonalizedFilterTitle": "Filtro personalizado",
+  "modalPersonalizedFilterSubTitle": "Gerencie seus filtros",
+  "modalInfoTextCreateEditPersonalized": "Use o layout antigo para criar ou editar filtros, em breve traremos uma nova experiência",
+  "modalOkButtonLabel": "Aplicar",
+  "modalCancelButtonLabel": "Limpar"
+};
+
+const snkTaskbarMessages = {
+  titleUpdate: "Editar",
+  titlePrevious: "Anterior",
+  titleNext: "Próximo",
+  titleRefresh: "Atualizar",
+  titleClone: "Duplicar",
+  titleRemove: "Excluir",
+  titleMoreOptions: "Mais Opções",
+  titleInsert: "Cadastrar",
+  titleCancel: "Cancelar",
+  titleSave: "Salvar",
+  titleGridMode: "Modo Grade",
+  titleFormMode: "Modo Formulário",
+  titleConfigurator: "Configurações",
+  forbidden: "Permissão não liberada"
+};
+
+const crudUtilsMessages = {
+  errorArray: "CrudUtils.find deve receber um array de fields, ou uma lista separada por virgula.",
+};
+
+const snkFormMessages = {
+  title: {
+    clone: "Duplicar registro",
+    insert: "Cadastrar registro",
+    update: "Alterar registro",
+    clean: "{{ENTITY_NAME}}"
+  },
+  goBackTitle: "Voltar"
+};
+const snkConfigOptionsMessages = {
+  label: {
+    nameField: "Nome do Campo *",
+    typeValueDefault: "Tipo de valor padrão *",
+    valueDefault: "Valor Padrão",
+    clearDuplicate: "Limpar ao Duplicar",
+    requiredField: "Campo Obrigatório",
+    protectedField: "Campo Protegido"
+  },
+  options: {
+    valueFixed: "Valor Fixo",
+    variable: "Variável"
+  }
+};
+const snkFormConfigMessages = {
+  title: "Configuração do formulário",
+  applyConfig: "Aplicar configuração",
+  availableFields: {
+    title: "Campos disponíveis",
+    labelNoFields: "Nenhum campo disponível",
+    labelOneField: "1 campo disponível",
+    labelAvailableFields: "Campos disponíveis",
+    labelSearchField: "Procurar campo"
+  },
+  form: {
+    subTitleInfo: "Inclua estes campos nos grupos ou deixe-os separados no topo do formulário!",
+    labelDropField: "Arraste e solte um campo aqui",
+    labelNewGroup: "Adicionar novo grupo",
+    mainArea: "Área principal",
+    tabGeneral: "Geral"
+  },
+  confirm: {
+    title: "Aviso",
+    deleteTab: "A aba selecionada será excluída.<br/><br/> Tem certeza que deseja excluir aba",
+    cancel: "As alterações realizadas serão descartadas.<br/><br/><b>Gostaria de continuar?</b>",
+    exit: "Ao sair as alterações serão descartadas.<br/><br/><b>Você realmente gostaria de sair?</b>",
+    apply: "A <b>{0}</b> irá substituir a sua configuração {1}!<br/><br/><b>Deseja continuar?</b>",
+    group: "Não é possível salvar as configurações com um grupo vazio!",
+    labelYes: "Sim",
+    labelNo: "Não"
+  },
+  alert: {
+    titleGroupExists: "Já existe um grupo com título",
+    infoValidTitle: "Por favor, digite um título válido.",
+    inTab: "na aba"
+  }
+};
+const snkFieldConfigMessages = {
+  titleRemove: "Remover",
+  titleConfigurations: "Configurações",
+  titleAdd: "Adicionar"
+};
+const snkTabConfigMessages = {
+  labelRename: "Renomear",
+  labelHide: "Ocultar",
+  labelShow: "Exibir",
+  labelDelete: "Excluir"
+};
+
+const snkConfiguratorMessages = {
+  msgSaveSuccessfully: "As configurações foram salvas com sucesso!"
+};
+const snkConfigModalMessages = {
+  titleConfigurations: "Configurações",
+  subTitleModeConfig: "Modo de visualização",
+  labelConfigGrid: "Configurar grade",
+  labelConfigForm: "Configurar formulário",
+  labelGrid: "Grade",
+  labelForm: "Formulário"
+};
+
+class SnkMessageBuilder {
+  constructor() {
+    this._defaults = {
+      snkDataUnit: snkDataUnitMessages,
+      snkForm: snkFormMessages,
+      snkFormConfig: snkFormConfigMessages,
+      snkConfigOptions: snkConfigOptionsMessages,
+      snkTaskbar: snkTaskbarMessages,
+      snkConfigModal: snkConfigModalMessages,
+      snkFieldConfig: snkFieldConfigMessages,
+      snkFilterBar: snkFilterBarMessages,
+      snkConfigurator: snkConfiguratorMessages,
+      snkTabConfig: snkTabConfigMessages,
+      crudUtils: crudUtilsMessages
+    };
+    this._currentOperation = OperationMap.CLEAN;
+    this.loadAppMessages().then((msgs) => {
+      this._appMessages = msgs;
+    }, error => {
+      console.info('O arquivo de mensagens personalizadas não foi encontrado no caminho /messages/appmessages.js', error);
+    });
+  }
+  /**
+   * Existem mensagens sensíveis a operação. Por exemplo, a mensagem
+   * de inclusão pode ser diferente da mensagem de alteração do mesmo
+   * recurso. Para isso "currentOperation" pode variar de acordo com
+   * OperationMap.
+   */
+  set currentOperation(op) {
+    this._currentOperation = op;
+  }
+  /**
+   * Método usado para se obter mensagens, respeitando o padrão do sistema
+   * ou as mensagens específicas de cada tela
+   *
+   * @param key Chave usada para obter mensagens. Deve-se usar o separador "."
+   * alcançar diversos níveis.
+   * @param params Quando a mensagem possui o padrão {{NOME}} as ocorrências
+   * serão substituidas pelo respectivo valor do param.
+   * @returns A mensagem formatada.
+   */
+  getMessage(key, params) {
+    if (key == undefined) {
+      return undefined;
+    }
+    var parts = key.split(".");
+    let msg = this.resolveMessage(parts, this._appMessages);
+    if (msg == undefined) {
+      msg = this.resolveMessage(parts, this._defaults);
+    }
+    if (this.customMessageBuilder) {
+      const result = this.customMessageBuilder(key, msg, params);
+      msg = result.message;
+      params = result.params;
+    }
+    return this.postProcess(msg, params);
+  }
+  resolveMessage(keys, object) {
+    if (object == undefined) {
+      return undefined;
+    }
+    const key = keys[0];
+    const result = object[key];
+    if (result) {
+      if (this.isOperationSensitive(result)) {
+        return result[this._currentOperation];
+      }
+      else {
+        const isLeaf = keys.length === 1 ||
+          result == undefined ||
+          typeof result === "string";
+        return isLeaf ? result : this.resolveMessage(keys.slice(1), result);
+      }
+    }
+  }
+  isOperationSensitive(value) {
+    return value[OperationMap.CLONE] != undefined ||
+      value[OperationMap.INSERT] != undefined ||
+      value[OperationMap.UPDATE] != undefined ||
+      value[OperationMap.CLEAN] != undefined;
+  }
+  postProcess(message, params) {
+    if (message) {
+      const propPattern = /(.*?)\{\{(.+?)\}\}/g;
+      let processed = "";
+      let tail = message;
+      let result;
+      while ((result = propPattern.exec(message)) !== null) {
+        const [match, head, attribute] = result;
+        const tailIndex = result.index + match.length;
+        tail = tailIndex < message.length ? message.substring(tailIndex) : "";
+        let replacement = params ? params[attribute] : undefined;
+        if (replacement == undefined) {
+          replacement = "";
+        }
+        processed += head + replacement;
+      }
+      return processed + tail;
+    }
+    else {
+      return message;
+    }
+  }
+  loadAppMessages() {
+    return new Promise((accept, reject) => {
+      const messagesUrl = window['applicationenv'] !== "dev" ? `/${window["MGE_MODULE_NAME"]}/labsApps/${window["APPLICATION_NAME"]}/build/messages/appmessages.js`
+        : '/messages/appmessages.js';
+      import(/* webpackIgnore: true */ messagesUrl)
+        .then(module => {
+        accept(module.default);
+      })
+        .catch(reason => {
+        reject(reason);
+      });
+    });
+  }
+}
+var OperationMap;
+(function (OperationMap) {
+  OperationMap["CLONE"] = "clone";
+  OperationMap["INSERT"] = "insert";
+  OperationMap["UPDATE"] = "update";
+  OperationMap["CLEAN"] = "clean";
+})(OperationMap || (OperationMap = {}));
+
+export { OperationMap as O, SnkMessageBuilder as S };

package/dist/esm/_commonjsHelpers-9943807e.js

@@ -0,0 +1,17 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function createCommonjsModule(fn, basedir, module) {
+	return module = {
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire();
+		}
+	}, fn(module, module.exports), module.exports;
+}
+
+function commonjsRequire () {
+	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+}
+
+export { commonjsGlobal as a, createCommonjsModule as c };

package/dist/esm/configurableElementsStorage-cdc144b5.js

@@ -0,0 +1,18 @@
+class ConfigurableElementsStorage {
+  static setGrid(id, grid) {
+    this._gridById.set(id, grid);
+  }
+  static setForm(id, form) {
+    this._formById.set(id, form);
+  }
+  static getGrid(id) {
+    return this._gridById.get(id);
+  }
+  static getForm(id) {
+    return this._formById.get(id);
+  }
+}
+ConfigurableElementsStorage._gridById = new Map();
+ConfigurableElementsStorage._formById = new Map();
+
+export { ConfigurableElementsStorage as C };