@projectcor/maia-components 2.38.1 → 2.38.2

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

@@ -0,0 +1,315 @@
+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);
+  })));
+  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('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","isReadOnly","getByText","toBeInTheDocument","toHaveValue","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  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('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":"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","ignoreList":[]}

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

@@ -33,7 +33,7 @@ export var SCASMFieldBox = styled.div.withConfig({
 export var SCASMFieldLabel = styled.label.withConfig({
   displayName: "AbmSkillModalstyles__SCASMFieldLabel",
   componentId: "sc-x2stxd-6"
-})(["color:#808080;font-family:'Work Sans',sans-serif;font-size:10px;font-weight:400;line-height:12px;text-transform:uppercase;cursor:text;"]);
+})(["color:#20201f;font-family:'Work Sans',sans-serif;font-size:10px;font-weight:400;line-height:12px;text-transform:uppercase;cursor:text;"]);
 export var SCASMFieldInput = styled.input.withConfig({
   displayName: "AbmSkillModalstyles__SCASMFieldInput",
   componentId: "sc-x2stxd-7"
@@ -159,4 +159,4 @@ export var SCASMCancelButton = styled.button.withConfig({
   displayName: "AbmSkillModalstyles__SCASMCancelButton",
   componentId: "sc-x2stxd-36"
 })(["", " border:none;background:transparent;color:#c70505;&:not(:disabled):hover{background:rgba(199,5,5,0.08);}"], scasmFooterButton);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["styled","css","scasmFooterButton","SCASMWrapper","div","withConfig","displayName","componentId","SCASMHeader","SCASMHeaderTitle","h2","SCASMCloseButton","button","SCASMBody","SCASMFieldBox","_ref","$height","concat","_ref2","$clipOverflow","SCASMFieldLabel","label","SCASMFieldInput","input","SCASMFieldTextarea","textarea","SCASMSwitchRow","SCASMSwitchLabel","span","SCASMInstructionsPanel","SCASMInstructionsHeader","SCASMInstructionsTitle","SCASMUploadButton","SCASMHiddenFileInput","SCASMInstructionsField","attrs","SCASMInstructionsTextarea","SCASMMetadataItem","SCASMMetadataLabel","SCASMMetadataValue","SCASMByteCounter","_ref3","$overLimit","SCASMFooter","SCASMDeleteSlot","SCASMSaveOutlinedButton","SCASMSavePrimaryButton","SCASMPreviewBody","SCASMPreviewHeadingBlock","SCASMPreviewName","h3","SCASMPreviewDescription","p","SCASMPreviewMetadataRow","SCASMPreviewMetadataLabel","SCASMPreviewMetadataValue","SCASMPreviewContentPanel","SCASMPreviewContentBox","SCASMUseSkillButton","SCASMCancelButton"],"sources":["../../../../src/components/organisms/AbmSkillModal/AbmSkillModal.styles.tsx"],"sourcesContent":["import styled, { css } from 'styled-components'\n\nconst scasmFooterButton = css`\n  display: flex;\n  box-sizing: border-box;\n  height: 32px;\n  padding: 0 12px;\n  justify-content: center;\n  align-items: center;\n  border-radius: 8px;\n  cursor: pointer;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 16px;\n  white-space: nowrap;\n\n  &:disabled {\n    opacity: 0.5;\n    cursor: not-allowed;\n  }\n`\n\nexport const SCASMWrapper = styled.div`\n  background-color: #fff;\n  border-radius: 8px;\n  box-shadow: 0 4px 16px rgba(18, 18, 18, 0.24);\n  width: 773px;\n  max-width: calc(100vw - 48px);\n  max-height: 655px;\n  z-index: 1001;\n  position: relative;\n  display: flex;\n  flex-direction: column;\n  gap: 12px;\n  overflow: hidden;\n`\n\nexport const SCASMHeader = styled.div`\n  display: flex;\n  padding: 14px 12px;\n  justify-content: space-between;\n  align-items: center;\n  align-self: stretch;\n  border-bottom: 1px solid #d9d9d9;\n  background: #fff;\n  flex-shrink: 0;\n`\n\nexport const SCASMHeaderTitle = styled.h2`\n  margin: 0;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 20px;\n  font-weight: 500;\n  line-height: 24px;\n  color: #20201f;\n`\n\nexport const SCASMCloseButton = styled.button`\n  display: flex;\n  width: 20px;\n  height: 20px;\n  align-items: center;\n  justify-content: center;\n  border: none;\n  background: transparent;\n  cursor: pointer;\n  padding: 0;\n  border-radius: 4px;\n\n  &:hover {\n    background: #f9f9f9;\n  }\n`\n\nexport const SCASMBody = styled.div`\n  display: flex;\n  flex-direction: column;\n  gap: 16px;\n  padding: 0 12px;\n  overflow-y: auto;\n  flex: 1;\n  min-height: 0;\n  align-self: stretch;\n`\n\nexport const SCASMFieldBox = styled.div<{ $height?: number; $clipOverflow?: boolean }>`\n  display: flex;\n  flex-direction: column;\n  align-items: stretch;\n  gap: 2px;\n  padding: 8px;\n  align-self: stretch;\n  border-radius: 4px;\n  border: 1px solid #d9d9d9;\n  background: #fff;\n  box-sizing: border-box;\n  ${({ $height }) =>\n    $height\n      ? `\n    height: ${$height}px;\n    min-height: ${$height}px;\n  `\n      : ''}\n  ${({ $clipOverflow }) => ($clipOverflow ? 'overflow: hidden;' : '')}\n\n  &:focus-within {\n    border-color: #08c;\n  }\n\n  &:focus-within label {\n    color: #08c;\n  }\n`\n\nexport const SCASMFieldLabel = styled.label`\n  color: #808080;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 10px;\n  font-weight: 400;\n  line-height: 12px;\n  text-transform: uppercase;\n  cursor: text;\n`\n\nexport const SCASMFieldInput = styled.input`\n  width: 100%;\n  align-self: stretch;\n  min-width: 0;\n  flex: 1;\n  min-height: 0;\n  border: none;\n  outline: none;\n  padding: 0;\n  background: transparent;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 20px;\n  color: #202020;\n\n  &::placeholder {\n    color: #999;\n  }\n\n  &:disabled {\n    color: #bfbfbf;\n  }\n`\n\nexport const SCASMFieldTextarea = styled.textarea`\n  width: 100%;\n  flex: 1;\n  align-self: stretch;\n  min-height: 0;\n  border: none;\n  outline: none;\n  padding: 0;\n  resize: none;\n  background: transparent;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 20px;\n  color: #202020;\n\n  &::placeholder {\n    color: #999;\n  }\n\n  &:disabled {\n    color: #bfbfbf;\n  }\n`\n\nexport const SCASMSwitchRow = styled.div`\n  display: flex;\n  align-items: center;\n  justify-content: flex-end;\n  gap: 6px;\n  align-self: stretch;\n`\n\nexport const SCASMSwitchLabel = styled.span`\n  color: #20201f;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 20px;\n`\n\nexport const SCASMInstructionsPanel = styled.div`\n  display: flex;\n  flex-direction: column;\n  align-items: flex-end;\n  gap: 4px;\n  align-self: stretch;\n  padding: 16px;\n  border-radius: 4px;\n  background: #f9f9f9;\n`\n\nexport const SCASMInstructionsHeader = styled.div`\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  align-self: stretch;\n  gap: 12px;\n`\n\nexport const SCASMInstructionsTitle = styled.span`\n  color: #20201f;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 16px;\n  font-weight: 500;\n  line-height: 20px;\n`\n\nexport const SCASMUploadButton = styled.button`\n  display: inline-flex;\n  min-width: 74px;\n  padding: 8px 12px;\n  justify-content: center;\n  align-items: center;\n  gap: 4px;\n  border: none;\n  border-radius: 8px;\n  background: transparent;\n  cursor: pointer;\n  color: #08c;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 12px;\n  font-weight: 400;\n  line-height: 14px;\n\n  &:hover {\n    background: rgba(0, 136, 204, 0.08);\n  }\n\n  &:disabled {\n    opacity: 0.5;\n    cursor: not-allowed;\n  }\n`\n\nexport const SCASMHiddenFileInput = styled.input`\n  position: absolute;\n  width: 1px;\n  height: 1px;\n  padding: 0;\n  margin: -1px;\n  border: 0;\n  overflow: hidden;\n  clip: rect(0, 0, 0, 0);\n  white-space: nowrap;\n`\n\nexport const SCASMInstructionsField = styled(SCASMFieldBox).attrs({ $clipOverflow: true })`\n  background: #fff;\n  height: 346px;\n  min-height: 346px;\n`\n\nexport const SCASMInstructionsTextarea = styled(SCASMFieldTextarea)``\n\nexport const SCASMMetadataItem = styled.div`\n  display: flex;\n  flex-direction: column;\n  align-items: flex-start;\n  gap: 4px;\n`\n\nexport const SCASMMetadataLabel = styled.span`\n  color: #000;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 20px;\n`\n\nexport const SCASMMetadataValue = styled.span`\n  color: #000;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 500;\n  line-height: 20px;\n`\n\nexport const SCASMByteCounter = styled.span<{ $overLimit?: boolean }>`\n  align-self: flex-end;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 12px;\n  line-height: 16px;\n  color: ${({ $overLimit }) => ($overLimit ? '#c70505' : '#999')};\n`\n\nexport const SCASMFooter = styled.div`\n  display: flex;\n  height: 61px;\n  padding: 12px;\n  justify-content: flex-end;\n  align-items: center;\n  gap: 10px;\n  align-self: stretch;\n  border-radius: 8px;\n  background: #fff;\n  flex-shrink: 0;\n`\n\nexport const SCASMDeleteSlot = styled.div`\n  margin-right: auto;\n`\n\nexport const SCASMSaveOutlinedButton = styled.button`\n  ${scasmFooterButton}\n  min-width: 64px;\n  border: 1px solid #08c;\n  background: #fff;\n  color: #08c;\n\n  &:not(:disabled):hover {\n    background: rgba(0, 136, 204, 0.08);\n  }\n`\n\nexport const SCASMSavePrimaryButton = styled.button`\n  ${scasmFooterButton}\n  min-width: 80px;\n  border: none;\n  background: #08c;\n  color: #fff;\n\n  &:not(:disabled):hover {\n    opacity: 0.92;\n  }\n`\n\nexport const SCASMPreviewBody = styled.div`\n  display: flex;\n  flex-direction: column;\n  gap: 18px;\n  padding: 0 12px 0 16px;\n  overflow-y: auto;\n  flex: 1;\n  min-height: 0;\n  align-self: stretch;\n`\n\nexport const SCASMPreviewHeadingBlock = styled.div`\n  display: flex;\n  flex-direction: column;\n  align-items: flex-start;\n  gap: 4px;\n  align-self: stretch;\n`\n\nexport const SCASMPreviewName = styled.h3`\n  margin: 0;\n  align-self: stretch;\n  color: #20201f;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 20px;\n  font-weight: 500;\n  line-height: 24px;\n`\n\nexport const SCASMPreviewDescription = styled.p`\n  margin: 0;\n  align-self: stretch;\n  color: #666;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 20px;\n`\n\nexport const SCASMPreviewMetadataRow = styled.div`\n  display: flex;\n  align-items: flex-start;\n  gap: 24px;\n`\n\nexport const SCASMPreviewMetadataLabel = styled(SCASMMetadataLabel)`\n  color: #4d4d4d;\n`\n\nexport const SCASMPreviewMetadataValue = styled(SCASMMetadataValue)`\n  color: #202020;\n`\n\nexport const SCASMPreviewContentPanel = styled.div`\n  display: flex;\n  flex-direction: column;\n  align-items: flex-start;\n  align-self: stretch;\n  gap: 8px;\n  padding: 16px;\n  border-radius: 4px;\n  background: #f9f9f9;\n`\n\nexport const SCASMPreviewContentBox = styled.div`\n  align-self: stretch;\n  max-height: 346px;\n  overflow-y: auto;\n  padding: 8px;\n  border-radius: 4px;\n  box-sizing: border-box;\n  color: #202020;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 20px;\n  white-space: pre-wrap;\n  word-break: break-word;\n`\n\nexport const SCASMUseSkillButton = styled(SCASMSavePrimaryButton)``\n\nexport const SCASMCancelButton = styled.button`\n  ${scasmFooterButton}\n  border: none;\n  background: transparent;\n  color: #c70505;\n\n  &:not(:disabled):hover {\n    background: rgba(199, 5, 5, 0.08);\n  }\n`\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["styled","css","scasmFooterButton","SCASMWrapper","div","withConfig","displayName","componentId","SCASMHeader","SCASMHeaderTitle","h2","SCASMCloseButton","button","SCASMBody","SCASMFieldBox","_ref","$height","concat","_ref2","$clipOverflow","SCASMFieldLabel","label","SCASMFieldInput","input","SCASMFieldTextarea","textarea","SCASMSwitchRow","SCASMSwitchLabel","span","SCASMInstructionsPanel","SCASMInstructionsHeader","SCASMInstructionsTitle","SCASMUploadButton","SCASMHiddenFileInput","SCASMInstructionsField","attrs","SCASMInstructionsTextarea","SCASMMetadataItem","SCASMMetadataLabel","SCASMMetadataValue","SCASMByteCounter","_ref3","$overLimit","SCASMFooter","SCASMDeleteSlot","SCASMSaveOutlinedButton","SCASMSavePrimaryButton","SCASMPreviewBody","SCASMPreviewHeadingBlock","SCASMPreviewName","h3","SCASMPreviewDescription","p","SCASMPreviewMetadataRow","SCASMPreviewMetadataLabel","SCASMPreviewMetadataValue","SCASMPreviewContentPanel","SCASMPreviewContentBox","SCASMUseSkillButton","SCASMCancelButton"],"sources":["../../../../src/components/organisms/AbmSkillModal/AbmSkillModal.styles.tsx"],"sourcesContent":["import styled, { css } from 'styled-components'\n\nconst scasmFooterButton = css`\n  display: flex;\n  box-sizing: border-box;\n  height: 32px;\n  padding: 0 12px;\n  justify-content: center;\n  align-items: center;\n  border-radius: 8px;\n  cursor: pointer;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 16px;\n  white-space: nowrap;\n\n  &:disabled {\n    opacity: 0.5;\n    cursor: not-allowed;\n  }\n`\n\nexport const SCASMWrapper = styled.div`\n  background-color: #fff;\n  border-radius: 8px;\n  box-shadow: 0 4px 16px rgba(18, 18, 18, 0.24);\n  width: 773px;\n  max-width: calc(100vw - 48px);\n  max-height: 655px;\n  z-index: 1001;\n  position: relative;\n  display: flex;\n  flex-direction: column;\n  gap: 12px;\n  overflow: hidden;\n`\n\nexport const SCASMHeader = styled.div`\n  display: flex;\n  padding: 14px 12px;\n  justify-content: space-between;\n  align-items: center;\n  align-self: stretch;\n  border-bottom: 1px solid #d9d9d9;\n  background: #fff;\n  flex-shrink: 0;\n`\n\nexport const SCASMHeaderTitle = styled.h2`\n  margin: 0;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 20px;\n  font-weight: 500;\n  line-height: 24px;\n  color: #20201f;\n`\n\nexport const SCASMCloseButton = styled.button`\n  display: flex;\n  width: 20px;\n  height: 20px;\n  align-items: center;\n  justify-content: center;\n  border: none;\n  background: transparent;\n  cursor: pointer;\n  padding: 0;\n  border-radius: 4px;\n\n  &:hover {\n    background: #f9f9f9;\n  }\n`\n\nexport const SCASMBody = styled.div`\n  display: flex;\n  flex-direction: column;\n  gap: 16px;\n  padding: 0 12px;\n  overflow-y: auto;\n  flex: 1;\n  min-height: 0;\n  align-self: stretch;\n`\n\nexport const SCASMFieldBox = styled.div<{ $height?: number; $clipOverflow?: boolean }>`\n  display: flex;\n  flex-direction: column;\n  align-items: stretch;\n  gap: 2px;\n  padding: 8px;\n  align-self: stretch;\n  border-radius: 4px;\n  border: 1px solid #d9d9d9;\n  background: #fff;\n  box-sizing: border-box;\n  ${({ $height }) =>\n    $height\n      ? `\n    height: ${$height}px;\n    min-height: ${$height}px;\n  `\n      : ''}\n  ${({ $clipOverflow }) => ($clipOverflow ? 'overflow: hidden;' : '')}\n\n  &:focus-within {\n    border-color: #08c;\n  }\n\n  &:focus-within label {\n    color: #08c;\n  }\n`\n\nexport const SCASMFieldLabel = styled.label`\n  color: #20201f;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 10px;\n  font-weight: 400;\n  line-height: 12px;\n  text-transform: uppercase;\n  cursor: text;\n`\n\nexport const SCASMFieldInput = styled.input`\n  width: 100%;\n  align-self: stretch;\n  min-width: 0;\n  flex: 1;\n  min-height: 0;\n  border: none;\n  outline: none;\n  padding: 0;\n  background: transparent;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 20px;\n  color: #202020;\n\n  &::placeholder {\n    color: #999;\n  }\n\n  &:disabled {\n    color: #bfbfbf;\n  }\n`\n\nexport const SCASMFieldTextarea = styled.textarea`\n  width: 100%;\n  flex: 1;\n  align-self: stretch;\n  min-height: 0;\n  border: none;\n  outline: none;\n  padding: 0;\n  resize: none;\n  background: transparent;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 20px;\n  color: #202020;\n\n  &::placeholder {\n    color: #999;\n  }\n\n  &:disabled {\n    color: #bfbfbf;\n  }\n`\n\nexport const SCASMSwitchRow = styled.div`\n  display: flex;\n  align-items: center;\n  justify-content: flex-end;\n  gap: 6px;\n  align-self: stretch;\n`\n\nexport const SCASMSwitchLabel = styled.span`\n  color: #20201f;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 20px;\n`\n\nexport const SCASMInstructionsPanel = styled.div`\n  display: flex;\n  flex-direction: column;\n  align-items: flex-end;\n  gap: 4px;\n  align-self: stretch;\n  padding: 16px;\n  border-radius: 4px;\n  background: #f9f9f9;\n`\n\nexport const SCASMInstructionsHeader = styled.div`\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  align-self: stretch;\n  gap: 12px;\n`\n\nexport const SCASMInstructionsTitle = styled.span`\n  color: #20201f;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 16px;\n  font-weight: 500;\n  line-height: 20px;\n`\n\nexport const SCASMUploadButton = styled.button`\n  display: inline-flex;\n  min-width: 74px;\n  padding: 8px 12px;\n  justify-content: center;\n  align-items: center;\n  gap: 4px;\n  border: none;\n  border-radius: 8px;\n  background: transparent;\n  cursor: pointer;\n  color: #08c;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 12px;\n  font-weight: 400;\n  line-height: 14px;\n\n  &:hover {\n    background: rgba(0, 136, 204, 0.08);\n  }\n\n  &:disabled {\n    opacity: 0.5;\n    cursor: not-allowed;\n  }\n`\n\nexport const SCASMHiddenFileInput = styled.input`\n  position: absolute;\n  width: 1px;\n  height: 1px;\n  padding: 0;\n  margin: -1px;\n  border: 0;\n  overflow: hidden;\n  clip: rect(0, 0, 0, 0);\n  white-space: nowrap;\n`\n\nexport const SCASMInstructionsField = styled(SCASMFieldBox).attrs({ $clipOverflow: true })`\n  background: #fff;\n  height: 346px;\n  min-height: 346px;\n`\n\nexport const SCASMInstructionsTextarea = styled(SCASMFieldTextarea)``\n\nexport const SCASMMetadataItem = styled.div`\n  display: flex;\n  flex-direction: column;\n  align-items: flex-start;\n  gap: 4px;\n`\n\nexport const SCASMMetadataLabel = styled.span`\n  color: #000;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 20px;\n`\n\nexport const SCASMMetadataValue = styled.span`\n  color: #000;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 500;\n  line-height: 20px;\n`\n\nexport const SCASMByteCounter = styled.span<{ $overLimit?: boolean }>`\n  align-self: flex-end;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 12px;\n  line-height: 16px;\n  color: ${({ $overLimit }) => ($overLimit ? '#c70505' : '#999')};\n`\n\nexport const SCASMFooter = styled.div`\n  display: flex;\n  height: 61px;\n  padding: 12px;\n  justify-content: flex-end;\n  align-items: center;\n  gap: 10px;\n  align-self: stretch;\n  border-radius: 8px;\n  background: #fff;\n  flex-shrink: 0;\n`\n\nexport const SCASMDeleteSlot = styled.div`\n  margin-right: auto;\n`\n\nexport const SCASMSaveOutlinedButton = styled.button`\n  ${scasmFooterButton}\n  min-width: 64px;\n  border: 1px solid #08c;\n  background: #fff;\n  color: #08c;\n\n  &:not(:disabled):hover {\n    background: rgba(0, 136, 204, 0.08);\n  }\n`\n\nexport const SCASMSavePrimaryButton = styled.button`\n  ${scasmFooterButton}\n  min-width: 80px;\n  border: none;\n  background: #08c;\n  color: #fff;\n\n  &:not(:disabled):hover {\n    opacity: 0.92;\n  }\n`\n\nexport const SCASMPreviewBody = styled.div`\n  display: flex;\n  flex-direction: column;\n  gap: 18px;\n  padding: 0 12px 0 16px;\n  overflow-y: auto;\n  flex: 1;\n  min-height: 0;\n  align-self: stretch;\n`\n\nexport const SCASMPreviewHeadingBlock = styled.div`\n  display: flex;\n  flex-direction: column;\n  align-items: flex-start;\n  gap: 4px;\n  align-self: stretch;\n`\n\nexport const SCASMPreviewName = styled.h3`\n  margin: 0;\n  align-self: stretch;\n  color: #20201f;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 20px;\n  font-weight: 500;\n  line-height: 24px;\n`\n\nexport const SCASMPreviewDescription = styled.p`\n  margin: 0;\n  align-self: stretch;\n  color: #666;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 20px;\n`\n\nexport const SCASMPreviewMetadataRow = styled.div`\n  display: flex;\n  align-items: flex-start;\n  gap: 24px;\n`\n\nexport const SCASMPreviewMetadataLabel = styled(SCASMMetadataLabel)`\n  color: #4d4d4d;\n`\n\nexport const SCASMPreviewMetadataValue = styled(SCASMMetadataValue)`\n  color: #202020;\n`\n\nexport const SCASMPreviewContentPanel = styled.div`\n  display: flex;\n  flex-direction: column;\n  align-items: flex-start;\n  align-self: stretch;\n  gap: 8px;\n  padding: 16px;\n  border-radius: 4px;\n  background: #f9f9f9;\n`\n\nexport const SCASMPreviewContentBox = styled.div`\n  align-self: stretch;\n  max-height: 346px;\n  overflow-y: auto;\n  padding: 8px;\n  border-radius: 4px;\n  box-sizing: border-box;\n  color: #202020;\n  font-family: 'Work Sans', sans-serif;\n  font-size: 14px;\n  font-weight: 400;\n  line-height: 20px;\n  white-space: pre-wrap;\n  word-break: break-word;\n`\n\nexport const SCASMUseSkillButton = styled(SCASMSavePrimaryButton)``\n\nexport const SCASMCancelButton = styled.button`\n  ${scasmFooterButton}\n  border: none;\n  background: transparent;\n  color: #c70505;\n\n  &:not(:disabled):hover {\n    background: rgba(199, 5, 5, 0.08);\n  }\n`\n"],"mappings":"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","ignoreList":[]}

package/lib/components/organisms/ChatAI/ChatAI.js

@@ -10,7 +10,6 @@ import { GlobalContext } from '../../../context/global-context';
 import { Features } from '../../atoms/WithFeatureValidation';
 import { withAppCfg } from '../../atoms/WithAppCfg';
 import { acquireChatsStore, releaseChatsStore } from '../../../store';
-import { useUsageStore } from '../../../store/useUsageStore';
 import { readMaiaPanelSession } from '../../../store/maiaPanelSessionPersistence';
 import { ensureSessionNotificationsInitialized } from '../../../store/sessions/sessionNotifications';
 import { useUser } from '../../../context/cor-user';
@@ -112,13 +111,9 @@ export var ChatAI = withAppCfg(function (_ref) {
   useEffect(function () {
     acquireChatsStore();
     ensureSessionNotificationsInitialized();
-    useUsageStore.getState().fetchUsage()["catch"](function () {
-      return undefined;
-    });
     return function () {
       deepLinkSendPendingRef.current = false;
       releaseChatsStore();
-      useUsageStore.getState().reset();
     };
   }, [user.id, user.company_id, initialSection]);
   var applyHostOpenDetail = useCallback(function (detail) {
@@ -182,4 +177,4 @@ export var ChatAI = withAppCfg(function (_ref) {
     children: /*#__PURE__*/_jsx(ChatAIModal, {})
   });
 }, Features.CHAT_AI);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useRef","useState","useMemo","useEffect","useCallback","useProjectSummaryConfig","ChatAIModal","GlobalContext","Features","withAppCfg","acquireChatsStore","releaseChatsStore","useUsageStore","readMaiaPanelSession","ensureSessionNotificationsInitialized","useUser","MAIA_OPEN_FROM_HOST_EVENT","jsx","_jsx","normalizeBannerEntryFaq","faq","_faq$faqId","_faq$faqTitle","id","faqId","trim","title","faqTitle","contextData","_typeof","undefined","_objectSpread","ChatAI","_ref","_savedHostContext$pro","initialEntity","entity","initialProject","project","initialClient","client","initialTask","task","_ref$hasMultiAgents","hasMultiAgents","_ref$section","section","initialSection","_ref$faq","initialFaqProp","_ref$initialDraft","initialDraft","initialDraftProp","_ref$minimizedPillAvo","minimizedPillAvoidAnchors","initialMinimizedPillAvoidAnchors","user","savedSessionOnMount","savedHostContext","isExpanded","hostContext","_useState","_savedHostContext$sec","_useState2","_slicedToArray","hostSection","setHostSection","_useState3","_useState4","hostEntity","setHostEntity","_useState5","_useState6","hostFaqProp","setHostFaqProp","_useState7","_useState8","hostInitialDraftProp","setHostInitialDraftProp","_useState9","_useState0","hostMinimizedPillAvoidAnchors","setHostMinimizedPillAvoidAnchors","_useState1","_ref2","_savedHostContext$cli","_useState10","hostClient","setHostClient","_useState11","_ref3","_savedHostContext$tas","_useState12","hostTask","setHostTask","initialProjectValue","_useState13","_useState14","setProject","_useProjectSummaryCon","context","deepLinkSendPendingRef","getState","fetchUsage","current","reset","company_id","applyHostOpenDetail","detail","_detail$faq","_detail$initialDraft","_detail$project","_detail$client","_detail$task","onOpenFromHost","event","_ref4","document","addEventListener","removeEventListener","bannerEntryFaq","draft","providerValue","Provider","value","children","CHAT_AI"],"sources":["../../../../src/components/organisms/ChatAI/ChatAI.tsx"],"sourcesContent":["import { useRef, useState, useMemo, useEffect, useCallback } from 'react'\nimport { useProjectSummaryConfig } from '../../../hooks/useProjectSummaryConfig'\nimport { Project } from '../../../types/Project'\nimport { Client } from '../../../types/Client'\nimport { Task } from '../../../types/Task'\nimport { ChatAIModal } from '../../molecules/ChatAIModal'\nimport { GlobalContext, type BannerEntryFaq, type MinimizedPillAvoidAnchor } from '../../../context/global-context'\nimport { Features } from '../../atoms/WithFeatureValidation'\nimport { withAppCfg } from '../../atoms/WithAppCfg'\nimport { acquireChatsStore, releaseChatsStore } from '../../../store'\nimport { useUsageStore } from '../../../store/useUsageStore'\nimport { readMaiaPanelSession } from '../../../store/maiaPanelSessionPersistence'\nimport { ensureSessionNotificationsInitialized } from '../../../store/sessions/sessionNotifications'\nimport { useUser } from '../../../context/cor-user'\nimport { MAIA_OPEN_FROM_HOST_EVENT, type MaiaHostOpenDetail, type MaiaHostSection } from '../../../utils/maiaHostOpen'\n\ntype ChatAIProps = {\n  entity: {\n    projectId: string | null\n    clientId: string | null\n  }\n  project: Project | null\n  client?: Client | null\n  task?: Task | null\n  hasMultiAgents?: boolean\n  section?: MaiaHostSection\n  /** Banner / host: abre el chat enviando la FAQ como mensaje y `X-Faq-Id` en el orchestrator */\n  faq?: BannerEntryFaq | null\n  initialDraft?: string | null\n  /** Selectores DOM del host que el pill minimizado debe esquivar al estar visible. */\n  minimizedPillAvoidAnchors?: MinimizedPillAvoidAnchor[]\n}\n\nconst normalizeBannerEntryFaq = (faq: BannerEntryFaq | null | undefined): BannerEntryFaq | null => {\n  const id = faq?.faqId?.trim()\n  const title = faq?.faqTitle?.trim()\n  if (!title) {\n    return null\n  }\n  const contextData = faq?.contextData != null && typeof faq.contextData === 'object' ? faq.contextData : undefined\n  return {\n    ...(id ? { faqId: id } : {}),\n    faqTitle: title,\n    ...(contextData ? { contextData } : {}),\n  }\n}\n\nexport const ChatAI = withAppCfg(\n  ({\n    entity: initialEntity,\n    project: initialProject,\n    client: initialClient,\n    task: initialTask,\n    hasMultiAgents = false,\n    section: initialSection = 'header',\n    faq: initialFaqProp = null,\n    initialDraft: initialDraftProp = null,\n    minimizedPillAvoidAnchors: initialMinimizedPillAvoidAnchors = [],\n  }: ChatAIProps) => {\n    const user = useUser()\n    const savedSessionOnMount = readMaiaPanelSession(user.id)\n    const savedHostContext = savedSessionOnMount?.isExpanded ? savedSessionOnMount.hostContext : undefined\n\n    const [hostSection, setHostSection] = useState<MaiaHostSection>(() => savedHostContext?.section ?? initialSection)\n    const [hostEntity, setHostEntity] = useState(initialEntity)\n    const [hostFaqProp, setHostFaqProp] = useState<BannerEntryFaq | null>(initialFaqProp)\n    const [hostInitialDraftProp, setHostInitialDraftProp] = useState<string | null>(initialDraftProp)\n    const [hostMinimizedPillAvoidAnchors, setHostMinimizedPillAvoidAnchors] = useState(initialMinimizedPillAvoidAnchors)\n    const [hostClient, setHostClient] = useState<Client | null>(() => savedHostContext?.client ?? initialClient ?? null)\n    const [hostTask, setHostTask] = useState<Task | null>(() => savedHostContext?.task ?? initialTask ?? null)\n\n    const initialProjectValue =\n      savedHostContext?.project ?? (hostSection === 'project' || hostSection === 'task' ? initialProject : null)\n    const [project, setProject] = useState<Project | null>(initialProjectValue)\n\n    useEffect(() => {\n      if ((hostSection === 'project' || hostSection === 'task') && initialProject != null) {\n        setProject(initialProject)\n      }\n    }, [hostSection, initialProject])\n\n    const { context } = useProjectSummaryConfig({\n      section: hostSection,\n      entity: hostEntity,\n      project,\n      setProject,\n      client: hostSection === 'client' ? hostClient : undefined,\n      task: hostSection === 'task' ? hostTask : undefined,\n      hasMultiAgents,\n    })\n    const deepLinkSendPendingRef = useRef(false)\n\n    useEffect(() => {\n      acquireChatsStore()\n      ensureSessionNotificationsInitialized()\n      useUsageStore\n        .getState()\n        .fetchUsage()\n        .catch(() => undefined)\n      return () => {\n        deepLinkSendPendingRef.current = false\n        releaseChatsStore()\n        useUsageStore.getState().reset()\n      }\n    }, [user.id, user.company_id, initialSection])\n\n    const applyHostOpenDetail = useCallback((detail: MaiaHostOpenDetail) => {\n      setHostSection(detail.section)\n      setHostEntity(detail.entity)\n      setHostFaqProp(detail.faq ?? null)\n      setHostInitialDraftProp(detail.initialDraft ?? null)\n      if (detail.minimizedPillAvoidAnchors != null) {\n        setHostMinimizedPillAvoidAnchors(detail.minimizedPillAvoidAnchors)\n      }\n\n      if (detail.section === 'project' || detail.section === 'task') {\n        setProject(detail.project ?? null)\n      } else {\n        setProject(null)\n      }\n\n      if (detail.section === 'client') {\n        setHostClient(detail.client ?? null)\n      } else if (detail.section === 'header' || detail.section === 'planner') {\n        setHostClient(null)\n      }\n\n      if (detail.section === 'task') {\n        setHostTask(detail.task ?? null)\n      } else {\n        setHostTask(null)\n      }\n    }, [])\n\n    useEffect(() => {\n      const onOpenFromHost = (event: Event) => {\n        const { detail } = event as CustomEvent<MaiaHostOpenDetail>\n        if (!detail) return\n        applyHostOpenDetail(detail)\n      }\n\n      document.addEventListener(MAIA_OPEN_FROM_HOST_EVENT, onOpenFromHost)\n      return () => {\n        document.removeEventListener(MAIA_OPEN_FROM_HOST_EVENT, onOpenFromHost)\n      }\n    }, [applyHostOpenDetail])\n\n    const bannerEntryFaq = useMemo(\n      () => normalizeBannerEntryFaq(hostFaqProp),\n      [hostFaqProp?.faqId, hostFaqProp?.faqTitle, hostFaqProp?.contextData]\n    )\n\n    const initialDraft = useMemo(() => {\n      const draft = hostInitialDraftProp?.trim()\n      return draft || null\n    }, [hostInitialDraftProp])\n\n    const providerValue = useMemo(\n      () => ({\n        ...context,\n        section: hostSection,\n        bannerEntryFaq,\n        initialDraft,\n        deepLinkSendPendingRef,\n        minimizedPillAvoidAnchors: hostMinimizedPillAvoidAnchors,\n      }),\n      [context, hostSection, bannerEntryFaq, initialDraft, hostMinimizedPillAvoidAnchors]\n    )\n\n    return (\n      <GlobalContext.Provider value={providerValue}>\n        <ChatAIModal />\n      </GlobalContext.Provider>\n    )\n  },\n  Features.CHAT_AI\n)\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useRef","useState","useMemo","useEffect","useCallback","useProjectSummaryConfig","ChatAIModal","GlobalContext","Features","withAppCfg","acquireChatsStore","releaseChatsStore","readMaiaPanelSession","ensureSessionNotificationsInitialized","useUser","MAIA_OPEN_FROM_HOST_EVENT","jsx","_jsx","normalizeBannerEntryFaq","faq","_faq$faqId","_faq$faqTitle","id","faqId","trim","title","faqTitle","contextData","_typeof","undefined","_objectSpread","ChatAI","_ref","_savedHostContext$pro","initialEntity","entity","initialProject","project","initialClient","client","initialTask","task","_ref$hasMultiAgents","hasMultiAgents","_ref$section","section","initialSection","_ref$faq","initialFaqProp","_ref$initialDraft","initialDraft","initialDraftProp","_ref$minimizedPillAvo","minimizedPillAvoidAnchors","initialMinimizedPillAvoidAnchors","user","savedSessionOnMount","savedHostContext","isExpanded","hostContext","_useState","_savedHostContext$sec","_useState2","_slicedToArray","hostSection","setHostSection","_useState3","_useState4","hostEntity","setHostEntity","_useState5","_useState6","hostFaqProp","setHostFaqProp","_useState7","_useState8","hostInitialDraftProp","setHostInitialDraftProp","_useState9","_useState0","hostMinimizedPillAvoidAnchors","setHostMinimizedPillAvoidAnchors","_useState1","_ref2","_savedHostContext$cli","_useState10","hostClient","setHostClient","_useState11","_ref3","_savedHostContext$tas","_useState12","hostTask","setHostTask","initialProjectValue","_useState13","_useState14","setProject","_useProjectSummaryCon","context","deepLinkSendPendingRef","current","company_id","applyHostOpenDetail","detail","_detail$faq","_detail$initialDraft","_detail$project","_detail$client","_detail$task","onOpenFromHost","event","_ref4","document","addEventListener","removeEventListener","bannerEntryFaq","draft","providerValue","Provider","value","children","CHAT_AI"],"sources":["../../../../src/components/organisms/ChatAI/ChatAI.tsx"],"sourcesContent":["import { useRef, useState, useMemo, useEffect, useCallback } from 'react'\nimport { useProjectSummaryConfig } from '../../../hooks/useProjectSummaryConfig'\nimport { Project } from '../../../types/Project'\nimport { Client } from '../../../types/Client'\nimport { Task } from '../../../types/Task'\nimport { ChatAIModal } from '../../molecules/ChatAIModal'\nimport { GlobalContext, type BannerEntryFaq, type MinimizedPillAvoidAnchor } from '../../../context/global-context'\nimport { Features } from '../../atoms/WithFeatureValidation'\nimport { withAppCfg } from '../../atoms/WithAppCfg'\nimport { acquireChatsStore, releaseChatsStore } from '../../../store'\nimport { readMaiaPanelSession } from '../../../store/maiaPanelSessionPersistence'\nimport { ensureSessionNotificationsInitialized } from '../../../store/sessions/sessionNotifications'\nimport { useUser } from '../../../context/cor-user'\nimport { MAIA_OPEN_FROM_HOST_EVENT, type MaiaHostOpenDetail, type MaiaHostSection } from '../../../utils/maiaHostOpen'\n\ntype ChatAIProps = {\n  entity: {\n    projectId: string | null\n    clientId: string | null\n  }\n  project: Project | null\n  client?: Client | null\n  task?: Task | null\n  hasMultiAgents?: boolean\n  section?: MaiaHostSection\n  /** Banner / host: abre el chat enviando la FAQ como mensaje y `X-Faq-Id` en el orchestrator */\n  faq?: BannerEntryFaq | null\n  initialDraft?: string | null\n  /** Selectores DOM del host que el pill minimizado debe esquivar al estar visible. */\n  minimizedPillAvoidAnchors?: MinimizedPillAvoidAnchor[]\n}\n\nconst normalizeBannerEntryFaq = (faq: BannerEntryFaq | null | undefined): BannerEntryFaq | null => {\n  const id = faq?.faqId?.trim()\n  const title = faq?.faqTitle?.trim()\n  if (!title) {\n    return null\n  }\n  const contextData = faq?.contextData != null && typeof faq.contextData === 'object' ? faq.contextData : undefined\n  return {\n    ...(id ? { faqId: id } : {}),\n    faqTitle: title,\n    ...(contextData ? { contextData } : {}),\n  }\n}\n\nexport const ChatAI = withAppCfg(\n  ({\n    entity: initialEntity,\n    project: initialProject,\n    client: initialClient,\n    task: initialTask,\n    hasMultiAgents = false,\n    section: initialSection = 'header',\n    faq: initialFaqProp = null,\n    initialDraft: initialDraftProp = null,\n    minimizedPillAvoidAnchors: initialMinimizedPillAvoidAnchors = [],\n  }: ChatAIProps) => {\n    const user = useUser()\n    const savedSessionOnMount = readMaiaPanelSession(user.id)\n    const savedHostContext = savedSessionOnMount?.isExpanded ? savedSessionOnMount.hostContext : undefined\n\n    const [hostSection, setHostSection] = useState<MaiaHostSection>(() => savedHostContext?.section ?? initialSection)\n    const [hostEntity, setHostEntity] = useState(initialEntity)\n    const [hostFaqProp, setHostFaqProp] = useState<BannerEntryFaq | null>(initialFaqProp)\n    const [hostInitialDraftProp, setHostInitialDraftProp] = useState<string | null>(initialDraftProp)\n    const [hostMinimizedPillAvoidAnchors, setHostMinimizedPillAvoidAnchors] = useState(initialMinimizedPillAvoidAnchors)\n    const [hostClient, setHostClient] = useState<Client | null>(() => savedHostContext?.client ?? initialClient ?? null)\n    const [hostTask, setHostTask] = useState<Task | null>(() => savedHostContext?.task ?? initialTask ?? null)\n\n    const initialProjectValue =\n      savedHostContext?.project ?? (hostSection === 'project' || hostSection === 'task' ? initialProject : null)\n    const [project, setProject] = useState<Project | null>(initialProjectValue)\n\n    useEffect(() => {\n      if ((hostSection === 'project' || hostSection === 'task') && initialProject != null) {\n        setProject(initialProject)\n      }\n    }, [hostSection, initialProject])\n\n    const { context } = useProjectSummaryConfig({\n      section: hostSection,\n      entity: hostEntity,\n      project,\n      setProject,\n      client: hostSection === 'client' ? hostClient : undefined,\n      task: hostSection === 'task' ? hostTask : undefined,\n      hasMultiAgents,\n    })\n    const deepLinkSendPendingRef = useRef(false)\n\n    useEffect(() => {\n      acquireChatsStore()\n      ensureSessionNotificationsInitialized()\n      return () => {\n        deepLinkSendPendingRef.current = false\n        releaseChatsStore()\n      }\n    }, [user.id, user.company_id, initialSection])\n\n    const applyHostOpenDetail = useCallback((detail: MaiaHostOpenDetail) => {\n      setHostSection(detail.section)\n      setHostEntity(detail.entity)\n      setHostFaqProp(detail.faq ?? null)\n      setHostInitialDraftProp(detail.initialDraft ?? null)\n      if (detail.minimizedPillAvoidAnchors != null) {\n        setHostMinimizedPillAvoidAnchors(detail.minimizedPillAvoidAnchors)\n      }\n\n      if (detail.section === 'project' || detail.section === 'task') {\n        setProject(detail.project ?? null)\n      } else {\n        setProject(null)\n      }\n\n      if (detail.section === 'client') {\n        setHostClient(detail.client ?? null)\n      } else if (detail.section === 'header' || detail.section === 'planner') {\n        setHostClient(null)\n      }\n\n      if (detail.section === 'task') {\n        setHostTask(detail.task ?? null)\n      } else {\n        setHostTask(null)\n      }\n    }, [])\n\n    useEffect(() => {\n      const onOpenFromHost = (event: Event) => {\n        const { detail } = event as CustomEvent<MaiaHostOpenDetail>\n        if (!detail) return\n        applyHostOpenDetail(detail)\n      }\n\n      document.addEventListener(MAIA_OPEN_FROM_HOST_EVENT, onOpenFromHost)\n      return () => {\n        document.removeEventListener(MAIA_OPEN_FROM_HOST_EVENT, onOpenFromHost)\n      }\n    }, [applyHostOpenDetail])\n\n    const bannerEntryFaq = useMemo(\n      () => normalizeBannerEntryFaq(hostFaqProp),\n      [hostFaqProp?.faqId, hostFaqProp?.faqTitle, hostFaqProp?.contextData]\n    )\n\n    const initialDraft = useMemo(() => {\n      const draft = hostInitialDraftProp?.trim()\n      return draft || null\n    }, [hostInitialDraftProp])\n\n    const providerValue = useMemo(\n      () => ({\n        ...context,\n        section: hostSection,\n        bannerEntryFaq,\n        initialDraft,\n        deepLinkSendPendingRef,\n        minimizedPillAvoidAnchors: hostMinimizedPillAvoidAnchors,\n      }),\n      [context, hostSection, bannerEntryFaq, initialDraft, hostMinimizedPillAvoidAnchors]\n    )\n\n    return (\n      <GlobalContext.Provider value={providerValue}>\n        <ChatAIModal />\n      </GlobalContext.Provider>\n    )\n  },\n  Features.CHAT_AI\n)\n"],"mappings":"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","ignoreList":[]}