@projectcor/maia-components 2.44.4 → 2.44.5-1

package/lib/components/organisms/AbmSkillGenerateModal/AbmSkillGenerateModal.spec.js

@@ -0,0 +1,112 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, fireEvent, renderWithProviders, screen, waitFor } from '../../../test/test-utils';
+import { ensurePortalRoot } from '../../../test/portalRoot';
+import { generateSkill } from '../../../services/maia/Skills/generateSkill';
+import { AbmSkillGenerateModal, SKILL_GENERATE_OPEN_EVENT } from './AbmSkillGenerateModal';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../../../services/maia/Skills/generateSkill', function () {
+  return {
+    generateSkill: jest.fn()
+  };
+});
+var handleSnackbarError = jest.fn();
+jest.mock('../../../hooks/useSnackBarManager/useSnackBarManager', function () {
+  return {
+    useSnackBarManager: function useSnackBarManager() {
+      return {
+        handleSnackbarError: handleSnackbarError
+      };
+    }
+  };
+});
+var openGenerateModal = function openGenerateModal() {
+  act(function () {
+    document.dispatchEvent(new CustomEvent(SKILL_GENERATE_OPEN_EVENT));
+  });
+};
+var generatedContent = "---\ndescription: Resume briefs\n---\nname: Brief skill\n# Body";
+describe('AbmSkillGenerateModal', function () {
+  var cleanupPortal;
+  var setValuesHandler;
+  beforeEach(function () {
+    cleanupPortal = ensurePortalRoot('modal-root-actions');
+    jest.clearAllMocks();
+    setValuesHandler = jest.fn();
+    document.addEventListener('abm-skill-modal-set-values', setValuesHandler);
+    generateSkill.mockResolvedValue({
+      content: generatedContent
+    });
+  });
+  afterEach(function () {
+    document.removeEventListener('abm-skill-modal-set-values', setValuesHandler);
+    cleanupPortal();
+  });
+  it('stays closed until the open event', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(AbmSkillGenerateModal, {})),
+      container = _renderWithProviders.container;
+    expect(container).toBeEmptyDOMElement();
+  });
+  it('generates a skill and hands off to the editor modal', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var event;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          renderWithProviders(/*#__PURE__*/_jsx(AbmSkillGenerateModal, {}));
+          openGenerateModal();
+          fireEvent.change(screen.getByPlaceholderText('mySkills.generatePlaceholder'), {
+            target: {
+              value: 'Crea un skill de briefs'
+            }
+          });
+          fireEvent.click(screen.getByRole('button', {
+            name: 'mySkills.createWithMaia'
+          }));
+          _context.next = 1;
+          return waitFor(function () {
+            expect(generateSkill).toHaveBeenCalledWith('Crea un skill de briefs');
+          });
+        case 1:
+          _context.next = 2;
+          return waitFor(function () {
+            expect(setValuesHandler).toHaveBeenCalled();
+          });
+        case 2:
+          event = setValuesHandler.mock.calls[0][0];
+          expect(event.detail.skillValues.values.general.name).toBe('Brief skill');
+          expect(event.detail.skillValues.values.general.description).toBe('Resume briefs');
+          expect(screen.queryByPlaceholderText('mySkills.generatePlaceholder')).not.toBeInTheDocument();
+        case 3:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('shows snackbar error when generation fails', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          ;
+          generateSkill.mockRejectedValue(new Error('fail'));
+          renderWithProviders(/*#__PURE__*/_jsx(AbmSkillGenerateModal, {}));
+          openGenerateModal();
+          fireEvent.change(screen.getByPlaceholderText('mySkills.generatePlaceholder'), {
+            target: {
+              value: 'Prompt'
+            }
+          });
+          fireEvent.click(screen.getByRole('button', {
+            name: 'mySkills.createWithMaia'
+          }));
+          _context2.next = 1;
+          return waitFor(function () {
+            expect(handleSnackbarError).toHaveBeenCalledWith('mySkills.generateError');
+          });
+        case 1:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","fireEvent","renderWithProviders","screen","waitFor","ensurePortalRoot","generateSkill","AbmSkillGenerateModal","SKILL_GENERATE_OPEN_EVENT","jsx","_jsx","jest","mock","fn","handleSnackbarError","useSnackBarManager","openGenerateModal","document","dispatchEvent","CustomEvent","generatedContent","describe","cleanupPortal","setValuesHandler","beforeEach","clearAllMocks","addEventListener","mockResolvedValue","content","afterEach","removeEventListener","it","_renderWithProviders","container","expect","toBeEmptyDOMElement","_asyncToGenerator","_regeneratorRuntime","mark","_callee","event","wrap","_context","prev","next","change","getByPlaceholderText","target","value","click","getByRole","name","toHaveBeenCalledWith","toHaveBeenCalled","calls","detail","skillValues","values","general","toBe","description","queryByPlaceholderText","not","toBeInTheDocument","stop","_callee2","_context2","mockRejectedValue","Error"],"sources":["../../../../src/components/organisms/AbmSkillGenerateModal/AbmSkillGenerateModal.spec.tsx"],"sourcesContent":["import { act, fireEvent, renderWithProviders, screen, waitFor } from '../../../test/test-utils'\nimport { ensurePortalRoot } from '../../../test/portalRoot'\nimport { generateSkill } from '../../../services/maia/Skills/generateSkill'\nimport { AbmSkillGenerateModal, SKILL_GENERATE_OPEN_EVENT } from './AbmSkillGenerateModal'\n\njest.mock('../../../services/maia/Skills/generateSkill', () => ({\n  generateSkill: jest.fn(),\n}))\n\nconst handleSnackbarError = jest.fn()\n\njest.mock('../../../hooks/useSnackBarManager/useSnackBarManager', () => ({\n  useSnackBarManager: () => ({ handleSnackbarError }),\n}))\n\nconst openGenerateModal = () => {\n  act(() => {\n    document.dispatchEvent(new CustomEvent(SKILL_GENERATE_OPEN_EVENT))\n  })\n}\n\nconst generatedContent = `---\ndescription: Resume briefs\n---\nname: Brief skill\n# Body`\n\ndescribe('AbmSkillGenerateModal', () => {\n  let cleanupPortal: () => void\n  let setValuesHandler: jest.Mock\n\n  beforeEach(() => {\n    cleanupPortal = ensurePortalRoot('modal-root-actions')\n    jest.clearAllMocks()\n    setValuesHandler = jest.fn()\n    document.addEventListener('abm-skill-modal-set-values', setValuesHandler)\n    ;(generateSkill as jest.Mock).mockResolvedValue({ content: generatedContent })\n  })\n\n  afterEach(() => {\n    document.removeEventListener('abm-skill-modal-set-values', setValuesHandler)\n    cleanupPortal()\n  })\n\n  it('stays closed until the open event', () => {\n    const { container } = renderWithProviders(<AbmSkillGenerateModal />)\n    expect(container).toBeEmptyDOMElement()\n  })\n\n  it('generates a skill and hands off to the editor modal', async () => {\n    renderWithProviders(<AbmSkillGenerateModal />)\n    openGenerateModal()\n\n    fireEvent.change(screen.getByPlaceholderText('mySkills.generatePlaceholder'), {\n      target: { value: 'Crea un skill de briefs' },\n    })\n    fireEvent.click(screen.getByRole('button', { name: 'mySkills.createWithMaia' }))\n\n    await waitFor(() => {\n      expect(generateSkill).toHaveBeenCalledWith('Crea un skill de briefs')\n    })\n\n    await waitFor(() => {\n      expect(setValuesHandler).toHaveBeenCalled()\n    })\n\n    const event = setValuesHandler.mock.calls[0][0] as CustomEvent\n    expect(event.detail.skillValues.values.general.name).toBe('Brief skill')\n    expect(event.detail.skillValues.values.general.description).toBe('Resume briefs')\n    expect(screen.queryByPlaceholderText('mySkills.generatePlaceholder')).not.toBeInTheDocument()\n  })\n\n  it('shows snackbar error when generation fails', async () => {\n    ;(generateSkill as jest.Mock).mockRejectedValue(new Error('fail'))\n    renderWithProviders(<AbmSkillGenerateModal />)\n    openGenerateModal()\n\n    fireEvent.change(screen.getByPlaceholderText('mySkills.generatePlaceholder'), {\n      target: { value: 'Prompt' },\n    })\n    fireEvent.click(screen.getByRole('button', { name: 'mySkills.createWithMaia' }))\n\n    await waitFor(() => {\n      expect(handleSnackbarError).toHaveBeenCalledWith('mySkills.generateError')\n    })\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/organisms/AbmSkillModal/AbmSkillModal.spec.js

@@ -0,0 +1,405 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, fireEvent, renderWithProviders, screen, waitFor } from '../../../test/test-utils';
+import { ensurePortalRoot } from '../../../test/portalRoot';
+import { createSkill } from '../../../services/maia/Skills/createSkill';
+import { updateSkill } from '../../../services/maia/Skills/updateSkill';
+import { AbmSkillModal } from './AbmSkillModal';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../../../services/maia/Skills/createSkill', function () {
+  return {
+    createSkill: jest.fn()
+  };
+});
+jest.mock('../../../services/maia/Skills/updateSkill', function () {
+  return {
+    updateSkill: jest.fn()
+  };
+});
+jest.mock('../../../services/maia/Skills/deleteSkill', function () {
+  return {
+    deleteSkill: jest.fn()
+  };
+});
+var handleSnackbarError = jest.fn();
+var handleSnackbarSuccess = jest.fn();
+jest.mock('../../../hooks/useSnackBarManager/useSnackBarManager', function () {
+  return {
+    useSnackBarManager: function useSnackBarManager() {
+      return {
+        handleSnackbarError: handleSnackbarError,
+        handleSnackbarSuccess: handleSnackbarSuccess
+      };
+    }
+  };
+});
+jest.mock('../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      aiChatSkillAbmCancel: 'AI_CHAT_SKILL_ABM_CANCEL',
+      aiChatSkillAbmConfirm: 'AI_CHAT_SKILL_ABM_CONFIRM',
+      aiChatSkillAbmDelete: 'AI_CHAT_SKILL_ABM_DELETE',
+      aiChatSkillUpload: 'AI_CHAT_SKILL_UPLOAD',
+      aiChatSkillUse: 'AI_CHAT_SKILL_USE'
+    },
+    useEvent: function useEvent() {
+      return jest.fn();
+    }
+  };
+});
+jest.mock('../../../context/cor-user', function () {
+  return {
+    useUser: function useUser() {
+      return {
+        id: 99,
+        firstName: 'Ada',
+        lastName: 'Lovelace',
+        role_id: 3,
+        permissions: {
+          ai_agents: {
+            create: true,
+            edit: true,
+            "delete": true
+          }
+        }
+      };
+    },
+    isCollaboratorRole: function isCollaboratorRole() {
+      return false;
+    }
+  };
+});
+jest.mock('../../../lang/utils', function () {
+  return {
+    formatDate: function formatDate() {
+      return '10 Sep, 2026';
+    }
+  };
+});
+jest.mock('../DeleteQuestionModal/DeleteQuestionModal', function () {
+  return {
+    DeleteQuestionModal: function DeleteQuestionModal(_ref) {
+      var handlers = _ref.handlers;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        onClick: function onClick() {
+          var _handlers$handleConfi;
+          return (_handlers$handleConfi = handlers.handleConfirmAction) === null || _handlers$handleConfi === void 0 ? void 0 : _handlers$handleConfi.call(handlers);
+        },
+        children: "confirm-delete"
+      });
+    }
+  };
+});
+var openSkill = function openSkill(values) {
+  var isOpen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  act(function () {
+    document.dispatchEvent(new CustomEvent('abm-skill-modal-set-values', {
+      detail: {
+        skillValues: {
+          isOpen: isOpen,
+          values: values
+        }
+      }
+    }));
+  });
+};
+var contentInput = function contentInput() {
+  return screen.getByPlaceholderText('mySkills.contentPlaceholder');
+};
+describe('AbmSkillModal', function () {
+  var cleanupPortal;
+  beforeEach(function () {
+    cleanupPortal = ensurePortalRoot('modal-root-actions');
+    jest.clearAllMocks();
+    createSkill.mockResolvedValue({
+      id: 'sk1',
+      name: 'Resumir',
+      description: 'Resume briefs',
+      content: 'Resume',
+      access_type: 'company'
+    });
+    updateSkill.mockResolvedValue({
+      id: 'sk1',
+      name: 'Resumir',
+      description: 'Desc',
+      content: 'Nuevo',
+      access_type: 'only_me'
+    });
+  });
+  afterEach(function () {
+    cleanupPortal();
+  });
+  it('stays closed until the open event', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(AbmSkillModal, {})),
+      container = _renderWithProviders.container;
+    expect(container).toBeEmptyDOMElement();
+  });
+  it('keeps save disabled without name or content', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(AbmSkillModal, {}));
+    openSkill({
+      isEditing: false,
+      general: {
+        name: '',
+        content: ''
+      }
+    });
+    expect(screen.getByRole('button', {
+      name: 'mySkills.save'
+    })).toBeDisabled();
+  });
+  it('creates a skill with description and company access', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var addSkill;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          addSkill = jest.fn();
+          renderWithProviders(/*#__PURE__*/_jsx(AbmSkillModal, {
+            addSkill: addSkill
+          }));
+          openSkill({
+            isEditing: false,
+            general: {
+              name: '',
+              description: '',
+              content: ''
+            }
+          });
+          fireEvent.change(screen.getByLabelText('mySkills.nameLabel'), {
+            target: {
+              value: 'Resumir'
+            }
+          });
+          fireEvent.change(screen.getByLabelText('mySkills.descriptionLabel'), {
+            target: {
+              value: 'Resume briefs'
+            }
+          });
+          fireEvent.change(contentInput(), {
+            target: {
+              value: 'Resume el brief'
+            }
+          });
+          fireEvent.click(screen.getByRole('switch', {
+            name: 'mySkills.shareWithCompany'
+          }));
+          fireEvent.click(screen.getByRole('button', {
+            name: 'mySkills.save'
+          }));
+          _context.next = 1;
+          return waitFor(function () {
+            expect(createSkill).toHaveBeenCalledWith({
+              name: 'Resumir',
+              description: 'Resume briefs',
+              content: 'Resume el brief',
+              access_type: 'company'
+            });
+            expect(addSkill).toHaveBeenCalledWith({
+              id: 'sk1',
+              name: 'Resumir',
+              description: 'Resume briefs',
+              content: 'Resume',
+              access_type: 'company'
+            });
+          });
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('updates an existing skill from the edit form', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var updateSkillInList;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          updateSkillInList = jest.fn();
+          renderWithProviders(/*#__PURE__*/_jsx(AbmSkillModal, {
+            updateSkillInList: updateSkillInList
+          }));
+          openSkill({
+            isEditing: true,
+            general: {
+              id: 'sk1',
+              name: 'Viejo',
+              description: 'Desc',
+              content: 'Texto',
+              access_type: 'only_me'
+            }
+          });
+          fireEvent.change(contentInput(), {
+            target: {
+              value: 'Texto nuevo'
+            }
+          });
+          fireEvent.click(screen.getByRole('button', {
+            name: 'mySkills.save'
+          }));
+          _context2.next = 1;
+          return waitFor(function () {
+            expect(updateSkill).toHaveBeenCalledWith('sk1', {
+              name: 'Viejo',
+              description: 'Desc',
+              content: 'Texto nuevo',
+              access_type: 'only_me'
+            });
+            expect(updateSkillInList).toHaveBeenCalled();
+          });
+        case 1:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  var clickBackdrop = function clickBackdrop() {
+    var _closeButton$parentEl;
+    var closeButton = screen.getByRole('button', {
+      name: 'mySkills.close'
+    });
+    var backdrop = (_closeButton$parentEl = closeButton.parentElement) === null || _closeButton$parentEl === void 0 || (_closeButton$parentEl = _closeButton$parentEl.parentElement) === null || _closeButton$parentEl === void 0 ? void 0 : _closeButton$parentEl.parentElement;
+    if (!backdrop) {
+      throw new Error('Backdrop not found');
+    }
+    fireEvent.click(backdrop);
+  };
+  it('does not close on backdrop click while creating or editing', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(AbmSkillModal, {}));
+    openSkill({
+      isEditing: false,
+      general: {
+        name: '',
+        description: '',
+        content: ''
+      }
+    });
+    fireEvent.change(screen.getByLabelText('mySkills.nameLabel'), {
+      target: {
+        value: 'Borrador'
+      }
+    });
+    clickBackdrop();
+    expect(screen.getByLabelText('mySkills.nameLabel')).toHaveValue('Borrador');
+    expect(screen.getByText('mySkills.createTitle')).toBeInTheDocument();
+  });
+  it('closes on backdrop click in read-only view mode', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(AbmSkillModal, {}));
+    openSkill({
+      isEditing: true,
+      isReadOnly: true,
+      general: {
+        id: 'sk1',
+        name: 'Resumir',
+        description: 'Desc',
+        content: 'Texto'
+      }
+    });
+    expect(screen.getByText('mySkills.viewOwnTitle')).toBeInTheDocument();
+    clickBackdrop();
+    expect(screen.queryByText('mySkills.viewOwnTitle')).not.toBeInTheDocument();
+  });
+  it('switches from view mode into the edit form', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(AbmSkillModal, {}));
+    openSkill({
+      isEditing: true,
+      isReadOnly: true,
+      general: {
+        id: 'sk1',
+        name: 'Resumir',
+        description: 'Desc',
+        content: 'Texto'
+      }
+    });
+    expect(screen.getByText('mySkills.viewOwnTitle')).toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', {
+      name: 'mySkills.edit'
+    }));
+    expect(screen.getByLabelText('mySkills.nameLabel')).toHaveValue('Resumir');
+  });
+  it('keeps the same delete action in view and edit', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(AbmSkillModal, {}));
+    openSkill({
+      isEditing: true,
+      isReadOnly: true,
+      general: {
+        id: 'sk1',
+        name: 'Resumir',
+        description: 'Desc',
+        content: 'Texto'
+      }
+    });
+    expect(screen.getByRole('button', {
+      name: 'mySkills.delete'
+    })).toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', {
+      name: 'mySkills.edit'
+    }));
+    expect(screen.getByRole('button', {
+      name: 'mySkills.delete'
+    })).toBeInTheDocument();
+  });
+  it('dispatches save and use with the first-agent flag after creating a skill', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var onUse, event;
+    return _regeneratorRuntime.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          onUse = jest.fn();
+          document.addEventListener('maia-use-skill-after-save', onUse);
+          renderWithProviders(/*#__PURE__*/_jsx(AbmSkillModal, {}));
+          openSkill({
+            isEditing: false,
+            general: {
+              name: '',
+              description: '',
+              content: ''
+            }
+          });
+          fireEvent.change(screen.getByLabelText('mySkills.nameLabel'), {
+            target: {
+              value: 'Resumir'
+            }
+          });
+          fireEvent.change(contentInput(), {
+            target: {
+              value: 'Resume el brief'
+            }
+          });
+          fireEvent.click(screen.getByRole('button', {
+            name: 'mySkills.saveAndUse'
+          }));
+          _context3.next = 1;
+          return waitFor(function () {
+            expect(onUse).toHaveBeenCalled();
+          });
+        case 1:
+          event = onUse.mock.calls[0][0];
+          expect(event.detail.skill.id).toBe('sk1');
+          expect(event.detail.useFirstAgent).toBe(true);
+          document.removeEventListener('maia-use-skill-after-save', onUse);
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('rejects a non-markdown upload', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(AbmSkillModal, {}));
+    openSkill({
+      isEditing: false,
+      general: {
+        name: '',
+        content: ''
+      }
+    });
+    var input = document.querySelector('input[type="file"]');
+    var file = new File(['hola'], 'nota.txt', {
+      type: 'text/plain'
+    });
+    fireEvent.change(input, {
+      target: {
+        files: [file]
+      }
+    });
+    expect(handleSnackbarError).toHaveBeenCalledWith('mySkills.uploadError');
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","fireEvent","renderWithProviders","screen","waitFor","ensurePortalRoot","createSkill","updateSkill","AbmSkillModal","jsx","_jsx","jest","mock","fn","deleteSkill","handleSnackbarError","handleSnackbarSuccess","useSnackBarManager","EVENTS","aiChatSkillAbmCancel","aiChatSkillAbmConfirm","aiChatSkillAbmDelete","aiChatSkillUpload","aiChatSkillUse","useEvent","useUser","id","firstName","lastName","role_id","permissions","ai_agents","create","edit","isCollaboratorRole","formatDate","DeleteQuestionModal","_ref","handlers","type","onClick","_handlers$handleConfi","handleConfirmAction","call","children","openSkill","values","isOpen","arguments","length","undefined","document","dispatchEvent","CustomEvent","detail","skillValues","contentInput","getByPlaceholderText","describe","cleanupPortal","beforeEach","clearAllMocks","mockResolvedValue","name","description","content","access_type","afterEach","it","_renderWithProviders","container","expect","toBeEmptyDOMElement","isEditing","general","getByRole","toBeDisabled","_asyncToGenerator","_regeneratorRuntime","mark","_callee","addSkill","wrap","_context","prev","next","change","getByLabelText","target","value","click","toHaveBeenCalledWith","stop","_callee2","updateSkillInList","_context2","toHaveBeenCalled","clickBackdrop","_closeButton$parentEl","closeButton","backdrop","parentElement","Error","toHaveValue","getByText","toBeInTheDocument","isReadOnly","queryByText","not","_callee3","onUse","event","_context3","addEventListener","calls","skill","toBe","useFirstAgent","removeEventListener","input","querySelector","file","File","files"],"sources":["../../../../src/components/organisms/AbmSkillModal/AbmSkillModal.spec.tsx"],"sourcesContent":["import { act, fireEvent, renderWithProviders, screen, waitFor } from '../../../test/test-utils'\nimport { ensurePortalRoot } from '../../../test/portalRoot'\nimport { createSkill } from '../../../services/maia/Skills/createSkill'\nimport { updateSkill } from '../../../services/maia/Skills/updateSkill'\nimport { AbmSkillModal } from './AbmSkillModal'\n\njest.mock('../../../services/maia/Skills/createSkill', () => ({\n  createSkill: jest.fn(),\n}))\n\njest.mock('../../../services/maia/Skills/updateSkill', () => ({\n  updateSkill: jest.fn(),\n}))\n\njest.mock('../../../services/maia/Skills/deleteSkill', () => ({\n  deleteSkill: jest.fn(),\n}))\n\nconst handleSnackbarError = jest.fn()\nconst handleSnackbarSuccess = jest.fn()\n\njest.mock('../../../hooks/useSnackBarManager/useSnackBarManager', () => ({\n  useSnackBarManager: () => ({ handleSnackbarError, handleSnackbarSuccess }),\n}))\n\njest.mock('../../../hooks/useEvent', () => ({\n  EVENTS: {\n    aiChatSkillAbmCancel: 'AI_CHAT_SKILL_ABM_CANCEL',\n    aiChatSkillAbmConfirm: 'AI_CHAT_SKILL_ABM_CONFIRM',\n    aiChatSkillAbmDelete: 'AI_CHAT_SKILL_ABM_DELETE',\n    aiChatSkillUpload: 'AI_CHAT_SKILL_UPLOAD',\n    aiChatSkillUse: 'AI_CHAT_SKILL_USE',\n  },\n  useEvent: () => jest.fn(),\n}))\n\njest.mock('../../../context/cor-user', () => ({\n  useUser: () => ({\n    id: 99,\n    firstName: 'Ada',\n    lastName: 'Lovelace',\n    role_id: 3,\n    permissions: { ai_agents: { create: true, edit: true, delete: true } },\n  }),\n  isCollaboratorRole: () => false,\n}))\n\njest.mock('../../../lang/utils', () => ({\n  formatDate: () => '10 Sep, 2026',\n}))\n\njest.mock('../DeleteQuestionModal/DeleteQuestionModal', () => ({\n  DeleteQuestionModal: ({ handlers }: { handlers: { handleConfirmAction?: () => void } }) => (\n    <button type=\"button\" onClick={() => handlers.handleConfirmAction?.()}>\n      confirm-delete\n    </button>\n  ),\n}))\n\nconst openSkill = (values: Record<string, unknown>, isOpen = true) => {\n  act(() => {\n    document.dispatchEvent(\n      new CustomEvent('abm-skill-modal-set-values', {\n        detail: { skillValues: { isOpen, values } },\n      })\n    )\n  })\n}\n\nconst contentInput = () => screen.getByPlaceholderText('mySkills.contentPlaceholder')\n\ndescribe('AbmSkillModal', () => {\n  let cleanupPortal: () => void\n\n  beforeEach(() => {\n    cleanupPortal = ensurePortalRoot('modal-root-actions')\n    jest.clearAllMocks()\n    ;(createSkill as jest.Mock).mockResolvedValue({\n      id: 'sk1',\n      name: 'Resumir',\n      description: 'Resume briefs',\n      content: 'Resume',\n      access_type: 'company',\n    })\n    ;(updateSkill as jest.Mock).mockResolvedValue({\n      id: 'sk1',\n      name: 'Resumir',\n      description: 'Desc',\n      content: 'Nuevo',\n      access_type: 'only_me',\n    })\n  })\n\n  afterEach(() => {\n    cleanupPortal()\n  })\n\n  it('stays closed until the open event', () => {\n    const { container } = renderWithProviders(<AbmSkillModal />)\n    expect(container).toBeEmptyDOMElement()\n  })\n\n  it('keeps save disabled without name or content', () => {\n    renderWithProviders(<AbmSkillModal />)\n    openSkill({ isEditing: false, general: { name: '', content: '' } })\n\n    expect(screen.getByRole('button', { name: 'mySkills.save' })).toBeDisabled()\n  })\n\n  it('creates a skill with description and company access', async () => {\n    const addSkill = jest.fn()\n    renderWithProviders(<AbmSkillModal addSkill={addSkill} />)\n    openSkill({ isEditing: false, general: { name: '', description: '', content: '' } })\n\n    fireEvent.change(screen.getByLabelText('mySkills.nameLabel'), { target: { value: 'Resumir' } })\n    fireEvent.change(screen.getByLabelText('mySkills.descriptionLabel'), { target: { value: 'Resume briefs' } })\n    fireEvent.change(contentInput(), { target: { value: 'Resume el brief' } })\n    fireEvent.click(screen.getByRole('switch', { name: 'mySkills.shareWithCompany' }))\n    fireEvent.click(screen.getByRole('button', { name: 'mySkills.save' }))\n\n    await waitFor(() => {\n      expect(createSkill).toHaveBeenCalledWith({\n        name: 'Resumir',\n        description: 'Resume briefs',\n        content: 'Resume el brief',\n        access_type: 'company',\n      })\n      expect(addSkill).toHaveBeenCalledWith({\n        id: 'sk1',\n        name: 'Resumir',\n        description: 'Resume briefs',\n        content: 'Resume',\n        access_type: 'company',\n      })\n    })\n  })\n\n  it('updates an existing skill from the edit form', async () => {\n    const updateSkillInList = jest.fn()\n    renderWithProviders(<AbmSkillModal updateSkillInList={updateSkillInList} />)\n    openSkill({\n      isEditing: true,\n      general: { id: 'sk1', name: 'Viejo', description: 'Desc', content: 'Texto', access_type: 'only_me' },\n    })\n\n    fireEvent.change(contentInput(), { target: { value: 'Texto nuevo' } })\n    fireEvent.click(screen.getByRole('button', { name: 'mySkills.save' }))\n\n    await waitFor(() => {\n      expect(updateSkill).toHaveBeenCalledWith('sk1', {\n        name: 'Viejo',\n        description: 'Desc',\n        content: 'Texto nuevo',\n        access_type: 'only_me',\n      })\n      expect(updateSkillInList).toHaveBeenCalled()\n    })\n  })\n\n  const clickBackdrop = () => {\n    const closeButton = screen.getByRole('button', { name: 'mySkills.close' })\n    const backdrop = closeButton.parentElement?.parentElement?.parentElement\n    if (!backdrop) {\n      throw new Error('Backdrop not found')\n    }\n    fireEvent.click(backdrop)\n  }\n\n  it('does not close on backdrop click while creating or editing', () => {\n    renderWithProviders(<AbmSkillModal />)\n    openSkill({ isEditing: false, general: { name: '', description: '', content: '' } })\n\n    fireEvent.change(screen.getByLabelText('mySkills.nameLabel'), { target: { value: 'Borrador' } })\n    clickBackdrop()\n\n    expect(screen.getByLabelText('mySkills.nameLabel')).toHaveValue('Borrador')\n    expect(screen.getByText('mySkills.createTitle')).toBeInTheDocument()\n  })\n\n  it('closes on backdrop click in read-only view mode', () => {\n    renderWithProviders(<AbmSkillModal />)\n    openSkill({\n      isEditing: true,\n      isReadOnly: true,\n      general: { id: 'sk1', name: 'Resumir', description: 'Desc', content: 'Texto' },\n    })\n\n    expect(screen.getByText('mySkills.viewOwnTitle')).toBeInTheDocument()\n    clickBackdrop()\n\n    expect(screen.queryByText('mySkills.viewOwnTitle')).not.toBeInTheDocument()\n  })\n\n  it('switches from view mode into the edit form', () => {\n    renderWithProviders(<AbmSkillModal />)\n    openSkill({\n      isEditing: true,\n      isReadOnly: true,\n      general: { id: 'sk1', name: 'Resumir', description: 'Desc', content: 'Texto' },\n    })\n\n    expect(screen.getByText('mySkills.viewOwnTitle')).toBeInTheDocument()\n    fireEvent.click(screen.getByRole('button', { name: 'mySkills.edit' }))\n    expect(screen.getByLabelText('mySkills.nameLabel')).toHaveValue('Resumir')\n  })\n\n  it('keeps the same delete action in view and edit', () => {\n    renderWithProviders(<AbmSkillModal />)\n    openSkill({\n      isEditing: true,\n      isReadOnly: true,\n      general: { id: 'sk1', name: 'Resumir', description: 'Desc', content: 'Texto' },\n    })\n\n    expect(screen.getByRole('button', { name: 'mySkills.delete' })).toBeInTheDocument()\n\n    fireEvent.click(screen.getByRole('button', { name: 'mySkills.edit' }))\n\n    expect(screen.getByRole('button', { name: 'mySkills.delete' })).toBeInTheDocument()\n  })\n\n  it('dispatches save and use with the first-agent flag after creating a skill', async () => {\n    const onUse = jest.fn()\n    document.addEventListener('maia-use-skill-after-save', onUse)\n\n    renderWithProviders(<AbmSkillModal />)\n    openSkill({ isEditing: false, general: { name: '', description: '', content: '' } })\n\n    fireEvent.change(screen.getByLabelText('mySkills.nameLabel'), { target: { value: 'Resumir' } })\n    fireEvent.change(contentInput(), { target: { value: 'Resume el brief' } })\n    fireEvent.click(screen.getByRole('button', { name: 'mySkills.saveAndUse' }))\n\n    await waitFor(() => {\n      expect(onUse).toHaveBeenCalled()\n    })\n\n    const event = onUse.mock.calls[0][0] as CustomEvent\n    expect(event.detail.skill.id).toBe('sk1')\n    expect(event.detail.useFirstAgent).toBe(true)\n\n    document.removeEventListener('maia-use-skill-after-save', onUse)\n  })\n\n  it('rejects a non-markdown upload', () => {\n    renderWithProviders(<AbmSkillModal />)\n    openSkill({ isEditing: false, general: { name: '', content: '' } })\n\n    const input = document.querySelector('input[type=\"file\"]') as HTMLInputElement\n    const file = new File(['hola'], 'nota.txt', { type: 'text/plain' })\n    fireEvent.change(input, { target: { files: [file] } })\n\n    expect(handleSnackbarError).toHaveBeenCalledWith('mySkills.uploadError')\n  })\n})\n"],"mappings":";;AAAA,SAASA,GAAG,EAAEC,SAAS,EAAEC,mBAAmB,EAAEC,MAAM,EAAEC,OAAO,QAAQ,0BAA0B;AAC/F,SAASC,gBAAgB,QAAQ,0BAA0B;AAC3D,SAASC,WAAW,QAAQ,2CAA2C;AACvE,SAASC,WAAW,QAAQ,2CAA2C;AACvE,SAASC,aAAa,QAAQ,iBAAiB;AAAA,SAAAC,GAAA,IAAAC,IAAA;AAE/CC,IAAI,CAACC,IAAI,CAAC,2CAA2C,EAAE;EAAA,OAAO;IAC5DN,WAAW,EAAEK,IAAI,CAACE,EAAE,CAAC;EACvB,CAAC;AAAA,CAAC,CAAC;AAEHF,IAAI,CAACC,IAAI,CAAC,2CAA2C,EAAE;EAAA,OAAO;IAC5DL,WAAW,EAAEI,IAAI,CAACE,EAAE,CAAC;EACvB,CAAC;AAAA,CAAC,CAAC;AAEHF,IAAI,CAACC,IAAI,CAAC,2CAA2C,EAAE;EAAA,OAAO;IAC5DE,WAAW,EAAEH,IAAI,CAACE,EAAE,CAAC;EACvB,CAAC;AAAA,CAAC,CAAC;AAEH,IAAME,mBAAmB,GAAGJ,IAAI,CAACE,EAAE,CAAC,CAAC;AACrC,IAAMG,qBAAqB,GAAGL,IAAI,CAACE,EAAE,CAAC,CAAC;AAEvCF,IAAI,CAACC,IAAI,CAAC,sDAAsD,EAAE;EAAA,OAAO;IACvEK,kBAAkB,EAAE,SAApBA,kBAAkBA,CAAA;MAAA,OAAS;QAAEF,mBAAmB,EAAnBA,mBAAmB;QAAEC,qBAAqB,EAArBA;MAAsB,CAAC;IAAA;EAC3E,CAAC;AAAA,CAAC,CAAC;AAEHL,IAAI,CAACC,IAAI,CAAC,yBAAyB,EAAE;EAAA,OAAO;IAC1CM,MAAM,EAAE;MACNC,oBAAoB,EAAE,0BAA0B;MAChDC,qBAAqB,EAAE,2BAA2B;MAClDC,oBAAoB,EAAE,0BAA0B;MAChDC,iBAAiB,EAAE,sBAAsB;MACzCC,cAAc,EAAE;IAClB,CAAC;IACDC,QAAQ,EAAE,SAAVA,QAAQA,CAAA;MAAA,OAAQb,IAAI,CAACE,EAAE,CAAC,CAAC;IAAA;EAC3B,CAAC;AAAA,CAAC,CAAC;AAEHF,IAAI,CAACC,IAAI,CAAC,2BAA2B,EAAE;EAAA,OAAO;IAC5Ca,OAAO,EAAE,SAATA,OAAOA,CAAA;MAAA,OAAS;QACdC,EAAE,EAAE,EAAE;QACNC,SAAS,EAAE,KAAK;QAChBC,QAAQ,EAAE,UAAU;QACpBC,OAAO,EAAE,CAAC;QACVC,WAAW,EAAE;UAAEC,SAAS,EAAE;YAAEC,MAAM,EAAE,IAAI;YAAEC,IAAI,EAAE,IAAI;YAAE,UAAQ;UAAK;QAAE;MACvE,CAAC;IAAA,CAAC;IACFC,kBAAkB,EAAE,SAApBA,kBAAkBA,CAAA;MAAA,OAAQ,KAAK;IAAA;EACjC,CAAC;AAAA,CAAC,CAAC;AAEHvB,IAAI,CAACC,IAAI,CAAC,qBAAqB,EAAE;EAAA,OAAO;IACtCuB,UAAU,EAAE,SAAZA,UAAUA,CAAA;MAAA,OAAQ,cAAc;IAAA;EAClC,CAAC;AAAA,CAAC,CAAC;AAEHxB,IAAI,CAACC,IAAI,CAAC,4CAA4C,EAAE;EAAA,OAAO;IAC7DwB,mBAAmB,EAAE,SAArBA,mBAAmBA,CAAAC,IAAA;MAAA,IAAKC,QAAQ,GAAAD,IAAA,CAARC,QAAQ;MAAA,oBAC9B5B,IAAA;QAAQ6B,IAAI,EAAC,QAAQ;QAACC,OAAO,EAAE,SAATA,OAAOA,CAAA;UAAA,IAAAC,qBAAA;UAAA,QAAAA,qBAAA,GAAQH,QAAQ,CAACI,mBAAmB,cAAAD,qBAAA,uBAA5BA,qBAAA,CAAAE,IAAA,CAAAL,QAA+B,CAAC;QAAA,CAAC;QAAAM,QAAA,EAAC;MAEvE,CAAQ,CAAC;IAAA;EAEb,CAAC;AAAA,CAAC,CAAC;AAEH,IAAMC,SAAS,GAAG,SAAZA,SAASA,CAAIC,MAA+B,EAAoB;EAAA,IAAlBC,MAAM,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,IAAI;EAC/DhD,GAAG,CAAC,YAAM;IACRmD,QAAQ,CAACC,aAAa,CACpB,IAAIC,WAAW,CAAC,4BAA4B,EAAE;MAC5CC,MAAM,EAAE;QAAEC,WAAW,EAAE;UAAER,MAAM,EAANA,MAAM;UAAED,MAAM,EAANA;QAAO;MAAE;IAC5C,CAAC,CACH,CAAC;EACH,CAAC,CAAC;AACJ,CAAC;AAED,IAAMU,YAAY,GAAG,SAAfA,YAAYA,CAAA;EAAA,OAASrD,MAAM,CAACsD,oBAAoB,CAAC,6BAA6B,CAAC;AAAA;AAErFC,QAAQ,CAAC,eAAe,EAAE,YAAM;EAC9B,IAAIC,aAAyB;EAE7BC,UAAU,CAAC,YAAM;IACfD,aAAa,GAAGtD,gBAAgB,CAAC,oBAAoB,CAAC;IACtDM,IAAI,CAACkD,aAAa,CAAC,CAAC;IAClBvD,WAAW,CAAewD,iBAAiB,CAAC;MAC5CpC,EAAE,EAAE,KAAK;MACTqC,IAAI,EAAE,SAAS;MACfC,WAAW,EAAE,eAAe;MAC5BC,OAAO,EAAE,QAAQ;MACjBC,WAAW,EAAE;IACf,CAAC,CAAC;IACA3D,WAAW,CAAeuD,iBAAiB,CAAC;MAC5CpC,EAAE,EAAE,KAAK;MACTqC,IAAI,EAAE,SAAS;MACfC,WAAW,EAAE,MAAM;MACnBC,OAAO,EAAE,OAAO;MAChBC,WAAW,EAAE;IACf,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFC,SAAS,CAAC,YAAM;IACdR,aAAa,CAAC,CAAC;EACjB,CAAC,CAAC;EAEFS,EAAE,CAAC,mCAAmC,EAAE,YAAM;IAC5C,IAAAC,oBAAA,GAAsBnE,mBAAmB,cAACQ,IAAA,CAACF,aAAa,IAAE,CAAC,CAAC;MAApD8D,SAAS,GAAAD,oBAAA,CAATC,SAAS;IACjBC,MAAM,CAACD,SAAS,CAAC,CAACE,mBAAmB,CAAC,CAAC;EACzC,CAAC,CAAC;EAEFJ,EAAE,CAAC,6CAA6C,EAAE,YAAM;IACtDlE,mBAAmB,cAACQ,IAAA,CAACF,aAAa,IAAE,CAAC,CAAC;IACtCqC,SAAS,CAAC;MAAE4B,SAAS,EAAE,KAAK;MAAEC,OAAO,EAAE;QAAEX,IAAI,EAAE,EAAE;QAAEE,OAAO,EAAE;MAAG;IAAE,CAAC,CAAC;IAEnEM,MAAM,CAACpE,MAAM,CAACwE,SAAS,CAAC,QAAQ,EAAE;MAAEZ,IAAI,EAAE;IAAgB,CAAC,CAAC,CAAC,CAACa,YAAY,CAAC,CAAC;EAC9E,CAAC,CAAC;EAEFR,EAAE,CAAC,qDAAqD,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAC,QAAA;IAAA,IAAAC,QAAA;IAAA,OAAAH,mBAAA,CAAAI,IAAA,WAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAClDJ,QAAQ,GAAGtE,IAAI,CAACE,EAAE,CAAC,CAAC;UAC1BX,mBAAmB,cAACQ,IAAA,CAACF,aAAa;YAACyE,QAAQ,EAAEA;UAAS,CAAE,CAAC,CAAC;UAC1DpC,SAAS,CAAC;YAAE4B,SAAS,EAAE,KAAK;YAAEC,OAAO,EAAE;cAAEX,IAAI,EAAE,EAAE;cAAEC,WAAW,EAAE,EAAE;cAAEC,OAAO,EAAE;YAAG;UAAE,CAAC,CAAC;UAEpFhE,SAAS,CAACqF,MAAM,CAACnF,MAAM,CAACoF,cAAc,CAAC,oBAAoB,CAAC,EAAE;YAAEC,MAAM,EAAE;cAAEC,KAAK,EAAE;YAAU;UAAE,CAAC,CAAC;UAC/FxF,SAAS,CAACqF,MAAM,CAACnF,MAAM,CAACoF,cAAc,CAAC,2BAA2B,CAAC,EAAE;YAAEC,MAAM,EAAE;cAAEC,KAAK,EAAE;YAAgB;UAAE,CAAC,CAAC;UAC5GxF,SAAS,CAACqF,MAAM,CAAC9B,YAAY,CAAC,CAAC,EAAE;YAAEgC,MAAM,EAAE;cAAEC,KAAK,EAAE;YAAkB;UAAE,CAAC,CAAC;UAC1ExF,SAAS,CAACyF,KAAK,CAACvF,MAAM,CAACwE,SAAS,CAAC,QAAQ,EAAE;YAAEZ,IAAI,EAAE;UAA4B,CAAC,CAAC,CAAC;UAClF9D,SAAS,CAACyF,KAAK,CAACvF,MAAM,CAACwE,SAAS,CAAC,QAAQ,EAAE;YAAEZ,IAAI,EAAE;UAAgB,CAAC,CAAC,CAAC;UAAAoB,QAAA,CAAAE,IAAA;UAAA,OAEhEjF,OAAO,CAAC,YAAM;YAClBmE,MAAM,CAACjE,WAAW,CAAC,CAACqF,oBAAoB,CAAC;cACvC5B,IAAI,EAAE,SAAS;cACfC,WAAW,EAAE,eAAe;cAC5BC,OAAO,EAAE,iBAAiB;cAC1BC,WAAW,EAAE;YACf,CAAC,CAAC;YACFK,MAAM,CAACU,QAAQ,CAAC,CAACU,oBAAoB,CAAC;cACpCjE,EAAE,EAAE,KAAK;cACTqC,IAAI,EAAE,SAAS;cACfC,WAAW,EAAE,eAAe;cAC5BC,OAAO,EAAE,QAAQ;cACjBC,WAAW,EAAE;YACf,CAAC,CAAC;UACJ,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAiB,QAAA,CAAAS,IAAA;MAAA;IAAA,GAAAZ,OAAA;EAAA,CACH,GAAC;EAEFZ,EAAE,CAAC,8CAA8C,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAAc,SAAA;IAAA,IAAAC,iBAAA;IAAA,OAAAhB,mBAAA,CAAAI,IAAA,WAAAa,SAAA;MAAA,kBAAAA,SAAA,CAAAX,IAAA,GAAAW,SAAA,CAAAV,IAAA;QAAA;UAC3CS,iBAAiB,GAAGnF,IAAI,CAACE,EAAE,CAAC,CAAC;UACnCX,mBAAmB,cAACQ,IAAA,CAACF,aAAa;YAACsF,iBAAiB,EAAEA;UAAkB,CAAE,CAAC,CAAC;UAC5EjD,SAAS,CAAC;YACR4B,SAAS,EAAE,IAAI;YACfC,OAAO,EAAE;cAAEhD,EAAE,EAAE,KAAK;cAAEqC,IAAI,EAAE,OAAO;cAAEC,WAAW,EAAE,MAAM;cAAEC,OAAO,EAAE,OAAO;cAAEC,WAAW,EAAE;YAAU;UACrG,CAAC,CAAC;UAEFjE,SAAS,CAACqF,MAAM,CAAC9B,YAAY,CAAC,CAAC,EAAE;YAAEgC,MAAM,EAAE;cAAEC,KAAK,EAAE;YAAc;UAAE,CAAC,CAAC;UACtExF,SAAS,CAACyF,KAAK,CAACvF,MAAM,CAACwE,SAAS,CAAC,QAAQ,EAAE;YAAEZ,IAAI,EAAE;UAAgB,CAAC,CAAC,CAAC;UAAAgC,SAAA,CAAAV,IAAA;UAAA,OAEhEjF,OAAO,CAAC,YAAM;YAClBmE,MAAM,CAAChE,WAAW,CAAC,CAACoF,oBAAoB,CAAC,KAAK,EAAE;cAC9C5B,IAAI,EAAE,OAAO;cACbC,WAAW,EAAE,MAAM;cACnBC,OAAO,EAAE,aAAa;cACtBC,WAAW,EAAE;YACf,CAAC,CAAC;YACFK,MAAM,CAACuB,iBAAiB,CAAC,CAACE,gBAAgB,CAAC,CAAC;UAC9C,CAAC,CAAC;QAAA;QAAA;UAAA,OAAAD,SAAA,CAAAH,IAAA;MAAA;IAAA,GAAAC,QAAA;EAAA,CACH,GAAC;EAEF,IAAMI,aAAa,GAAG,SAAhBA,aAAaA,CAAA,EAAS;IAAA,IAAAC,qBAAA;IAC1B,IAAMC,WAAW,GAAGhG,MAAM,CAACwE,SAAS,CAAC,QAAQ,EAAE;MAAEZ,IAAI,EAAE;IAAiB,CAAC,CAAC;IAC1E,IAAMqC,QAAQ,IAAAF,qBAAA,GAAGC,WAAW,CAACE,aAAa,cAAAH,qBAAA,gBAAAA,qBAAA,GAAzBA,qBAAA,CAA2BG,aAAa,cAAAH,qBAAA,uBAAxCA,qBAAA,CAA0CG,aAAa;IACxE,IAAI,CAACD,QAAQ,EAAE;MACb,MAAM,IAAIE,KAAK,CAAC,oBAAoB,CAAC;IACvC;IACArG,SAAS,CAACyF,KAAK,CAACU,QAAQ,CAAC;EAC3B,CAAC;EAEDhC,EAAE,CAAC,4DAA4D,EAAE,YAAM;IACrElE,mBAAmB,cAACQ,IAAA,CAACF,aAAa,IAAE,CAAC,CAAC;IACtCqC,SAAS,CAAC;MAAE4B,SAAS,EAAE,KAAK;MAAEC,OAAO,EAAE;QAAEX,IAAI,EAAE,EAAE;QAAEC,WAAW,EAAE,EAAE;QAAEC,OAAO,EAAE;MAAG;IAAE,CAAC,CAAC;IAEpFhE,SAAS,CAACqF,MAAM,CAACnF,MAAM,CAACoF,cAAc,CAAC,oBAAoB,CAAC,EAAE;MAAEC,MAAM,EAAE;QAAEC,KAAK,EAAE;MAAW;IAAE,CAAC,CAAC;IAChGQ,aAAa,CAAC,CAAC;IAEf1B,MAAM,CAACpE,MAAM,CAACoF,cAAc,CAAC,oBAAoB,CAAC,CAAC,CAACgB,WAAW,CAAC,UAAU,CAAC;IAC3EhC,MAAM,CAACpE,MAAM,CAACqG,SAAS,CAAC,sBAAsB,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;EACtE,CAAC,CAAC;EAEFrC,EAAE,CAAC,iDAAiD,EAAE,YAAM;IAC1DlE,mBAAmB,cAACQ,IAAA,CAACF,aAAa,IAAE,CAAC,CAAC;IACtCqC,SAAS,CAAC;MACR4B,SAAS,EAAE,IAAI;MACfiC,UAAU,EAAE,IAAI;MAChBhC,OAAO,EAAE;QAAEhD,EAAE,EAAE,KAAK;QAAEqC,IAAI,EAAE,SAAS;QAAEC,WAAW,EAAE,MAAM;QAAEC,OAAO,EAAE;MAAQ;IAC/E,CAAC,CAAC;IAEFM,MAAM,CAACpE,MAAM,CAACqG,SAAS,CAAC,uBAAuB,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;IACrER,aAAa,CAAC,CAAC;IAEf1B,MAAM,CAACpE,MAAM,CAACwG,WAAW,CAAC,uBAAuB,CAAC,CAAC,CAACC,GAAG,CAACH,iBAAiB,CAAC,CAAC;EAC7E,CAAC,CAAC;EAEFrC,EAAE,CAAC,4CAA4C,EAAE,YAAM;IACrDlE,mBAAmB,cAACQ,IAAA,CAACF,aAAa,IAAE,CAAC,CAAC;IACtCqC,SAAS,CAAC;MACR4B,SAAS,EAAE,IAAI;MACfiC,UAAU,EAAE,IAAI;MAChBhC,OAAO,EAAE;QAAEhD,EAAE,EAAE,KAAK;QAAEqC,IAAI,EAAE,SAAS;QAAEC,WAAW,EAAE,MAAM;QAAEC,OAAO,EAAE;MAAQ;IAC/E,CAAC,CAAC;IAEFM,MAAM,CAACpE,MAAM,CAACqG,SAAS,CAAC,uBAAuB,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;IACrExG,SAAS,CAACyF,KAAK,CAACvF,MAAM,CAACwE,SAAS,CAAC,QAAQ,EAAE;MAAEZ,IAAI,EAAE;IAAgB,CAAC,CAAC,CAAC;IACtEQ,MAAM,CAACpE,MAAM,CAACoF,cAAc,CAAC,oBAAoB,CAAC,CAAC,CAACgB,WAAW,CAAC,SAAS,CAAC;EAC5E,CAAC,CAAC;EAEFnC,EAAE,CAAC,+CAA+C,EAAE,YAAM;IACxDlE,mBAAmB,cAACQ,IAAA,CAACF,aAAa,IAAE,CAAC,CAAC;IACtCqC,SAAS,CAAC;MACR4B,SAAS,EAAE,IAAI;MACfiC,UAAU,EAAE,IAAI;MAChBhC,OAAO,EAAE;QAAEhD,EAAE,EAAE,KAAK;QAAEqC,IAAI,EAAE,SAAS;QAAEC,WAAW,EAAE,MAAM;QAAEC,OAAO,EAAE;MAAQ;IAC/E,CAAC,CAAC;IAEFM,MAAM,CAACpE,MAAM,CAACwE,SAAS,CAAC,QAAQ,EAAE;MAAEZ,IAAI,EAAE;IAAkB,CAAC,CAAC,CAAC,CAAC0C,iBAAiB,CAAC,CAAC;IAEnFxG,SAAS,CAACyF,KAAK,CAACvF,MAAM,CAACwE,SAAS,CAAC,QAAQ,EAAE;MAAEZ,IAAI,EAAE;IAAgB,CAAC,CAAC,CAAC;IAEtEQ,MAAM,CAACpE,MAAM,CAACwE,SAAS,CAAC,QAAQ,EAAE;MAAEZ,IAAI,EAAE;IAAkB,CAAC,CAAC,CAAC,CAAC0C,iBAAiB,CAAC,CAAC;EACrF,CAAC,CAAC;EAEFrC,EAAE,CAAC,0EAA0E,eAAAS,iBAAA,cAAAC,mBAAA,CAAAC,IAAA,CAAE,SAAA8B,SAAA;IAAA,IAAAC,KAAA,EAAAC,KAAA;IAAA,OAAAjC,mBAAA,CAAAI,IAAA,WAAA8B,SAAA;MAAA,kBAAAA,SAAA,CAAA5B,IAAA,GAAA4B,SAAA,CAAA3B,IAAA;QAAA;UACvEyB,KAAK,GAAGnG,IAAI,CAACE,EAAE,CAAC,CAAC;UACvBsC,QAAQ,CAAC8D,gBAAgB,CAAC,2BAA2B,EAAEH,KAAK,CAAC;UAE7D5G,mBAAmB,cAACQ,IAAA,CAACF,aAAa,IAAE,CAAC,CAAC;UACtCqC,SAAS,CAAC;YAAE4B,SAAS,EAAE,KAAK;YAAEC,OAAO,EAAE;cAAEX,IAAI,EAAE,EAAE;cAAEC,WAAW,EAAE,EAAE;cAAEC,OAAO,EAAE;YAAG;UAAE,CAAC,CAAC;UAEpFhE,SAAS,CAACqF,MAAM,CAACnF,MAAM,CAACoF,cAAc,CAAC,oBAAoB,CAAC,EAAE;YAAEC,MAAM,EAAE;cAAEC,KAAK,EAAE;YAAU;UAAE,CAAC,CAAC;UAC/FxF,SAAS,CAACqF,MAAM,CAAC9B,YAAY,CAAC,CAAC,EAAE;YAAEgC,MAAM,EAAE;cAAEC,KAAK,EAAE;YAAkB;UAAE,CAAC,CAAC;UAC1ExF,SAAS,CAACyF,KAAK,CAACvF,MAAM,CAACwE,SAAS,CAAC,QAAQ,EAAE;YAAEZ,IAAI,EAAE;UAAsB,CAAC,CAAC,CAAC;UAAAiD,SAAA,CAAA3B,IAAA;UAAA,OAEtEjF,OAAO,CAAC,YAAM;YAClBmE,MAAM,CAACuC,KAAK,CAAC,CAACd,gBAAgB,CAAC,CAAC;UAClC,CAAC,CAAC;QAAA;UAEIe,KAAK,GAAGD,KAAK,CAAClG,IAAI,CAACsG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;UACpC3C,MAAM,CAACwC,KAAK,CAACzD,MAAM,CAAC6D,KAAK,CAACzF,EAAE,CAAC,CAAC0F,IAAI,CAAC,KAAK,CAAC;UACzC7C,MAAM,CAACwC,KAAK,CAACzD,MAAM,CAAC+D,aAAa,CAAC,CAACD,IAAI,CAAC,IAAI,CAAC;UAE7CjE,QAAQ,CAACmE,mBAAmB,CAAC,2BAA2B,EAAER,KAAK,CAAC;QAAA;QAAA;UAAA,OAAAE,SAAA,CAAApB,IAAA;MAAA;IAAA,GAAAiB,QAAA;EAAA,CACjE,GAAC;EAEFzC,EAAE,CAAC,+BAA+B,EAAE,YAAM;IACxClE,mBAAmB,cAACQ,IAAA,CAACF,aAAa,IAAE,CAAC,CAAC;IACtCqC,SAAS,CAAC;MAAE4B,SAAS,EAAE,KAAK;MAAEC,OAAO,EAAE;QAAEX,IAAI,EAAE,EAAE;QAAEE,OAAO,EAAE;MAAG;IAAE,CAAC,CAAC;IAEnE,IAAMsD,KAAK,GAAGpE,QAAQ,CAACqE,aAAa,CAAC,oBAAoB,CAAqB;IAC9E,IAAMC,IAAI,GAAG,IAAIC,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE;MAAEnF,IAAI,EAAE;IAAa,CAAC,CAAC;IACnEtC,SAAS,CAACqF,MAAM,CAACiC,KAAK,EAAE;MAAE/B,MAAM,EAAE;QAAEmC,KAAK,EAAE,CAACF,IAAI;MAAE;IAAE,CAAC,CAAC;IAEtDlD,MAAM,CAACxD,mBAAmB,CAAC,CAAC4E,oBAAoB,CAAC,sBAAsB,CAAC;EAC1E,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}