@projectcor/maia-components 2.49.0 → 2.49.1-0

package/lib/components/molecules/AbmSection/AbmGeneralSection.helpers.spec.js

@@ -0,0 +1,107 @@
+import { buildAbmGeneralFormValues, computeModelDropdownHeight, filterAvailableAgentModels, MODEL_DROPDOWN_GAP, MODEL_DROPDOWN_MAX_HEIGHT, MODEL_OPTION_HEIGHT, resolveDropdownPosition, resolveModelDropdownToggleState, shouldCloseModelDropdownOnEscape, shouldCloseModelDropdownOnOutsideClick, shouldRegisterModelDropdownListeners, shouldRepositionModelDropdown, shouldUpdateSelectedAgentModel, VALIDATION_FIELDS_RULES } from './AbmGeneralSection.helpers';
+describe('AbmGeneralSection.helpers', function () {
+  it('exposes validation limits for general fields', function () {
+    expect(VALIDATION_FIELDS_RULES.name).toBe(150);
+    expect(VALIDATION_FIELDS_RULES.userPrompt).toBe(5000);
+  });
+  describe('resolveDropdownPosition', function () {
+    var anchor = {
+      left: 20,
+      top: 100,
+      bottom: 140,
+      width: 300
+    };
+    it('opens below when there is enough space', function () {
+      expect(resolveDropdownPosition(anchor, 200, 800)).toEqual({
+        left: 20,
+        width: 300,
+        top: 140 + MODEL_DROPDOWN_GAP,
+        placement: 'bottom'
+      });
+    });
+    it('opens below when below space is larger than above even if tight', function () {
+      var tightBottom = {
+        left: 10,
+        top: 250,
+        bottom: 290,
+        width: 200
+      };
+      expect(resolveDropdownPosition(tightBottom, 200, 500)).toMatchObject({
+        placement: 'bottom',
+        top: 294
+      });
+    });
+    it('opens above when there is more room on top', function () {
+      var tightAnchor = {
+        left: 20,
+        top: 400,
+        bottom: 440,
+        width: 300
+      };
+      expect(resolveDropdownPosition(tightAnchor, 400, 500)).toEqual({
+        left: 20,
+        width: 300,
+        bottom: 500 - 400 + MODEL_DROPDOWN_GAP,
+        placement: 'top'
+      });
+    });
+  });
+  describe('filterAvailableAgentModels', function () {
+    it('removes deprecated models', function () {
+      var models = [{
+        id: 1,
+        display_name: 'Active'
+      }, {
+        id: 2,
+        display_name: 'Legacy',
+        is_deprecated: true
+      }];
+      expect(filterAvailableAgentModels(models)).toEqual([models[0]]);
+    });
+  });
+  describe('form and dropdown helpers', function () {
+    it('builds initial form values with defaults', function () {
+      expect(buildAbmGeneralFormValues({})).toEqual({
+        name: '',
+        aiModel: null,
+        inputPlaceholder: '',
+        introduction: '',
+        userPrompt: '',
+        emoji: ''
+      });
+      expect(buildAbmGeneralFormValues({
+        name: 'Bot',
+        aiModel: {
+          id: 1,
+          display_name: 'GPT'
+        },
+        inputPlaceholder: 'Ask',
+        introduction: 'Hi',
+        userPrompt: 'Help',
+        emoji: '🤖'
+      })).toMatchObject({
+        name: 'Bot',
+        emoji: '🤖',
+        userPrompt: 'Help'
+      });
+    });
+    it('controls model dropdown interactions', function () {
+      expect(resolveModelDropdownToggleState(false)).toBe(true);
+      expect(shouldCloseModelDropdownOnOutsideClick(true, false, false)).toBe(true);
+      expect(shouldCloseModelDropdownOnOutsideClick(true, true, false)).toBe(false);
+      expect(shouldCloseModelDropdownOnEscape('Escape', true)).toBe(true);
+      expect(shouldCloseModelDropdownOnEscape('Enter', true)).toBe(false);
+      expect(shouldRegisterModelDropdownListeners(true)).toBe(true);
+      expect(shouldRepositionModelDropdown(false)).toBe(false);
+      expect(shouldUpdateSelectedAgentModel(1, 2)).toBe(true);
+      expect(shouldUpdateSelectedAgentModel(2, 2)).toBe(false);
+    });
+  });
+  describe('computeModelDropdownHeight', function () {
+    it('caps dropdown height to the configured maximum', function () {
+      expect(computeModelDropdownHeight(2)).toBe(2 * MODEL_OPTION_HEIGHT + 2);
+      expect(computeModelDropdownHeight(10)).toBe(MODEL_DROPDOWN_MAX_HEIGHT);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["buildAbmGeneralFormValues","computeModelDropdownHeight","filterAvailableAgentModels","MODEL_DROPDOWN_GAP","MODEL_DROPDOWN_MAX_HEIGHT","MODEL_OPTION_HEIGHT","resolveDropdownPosition","resolveModelDropdownToggleState","shouldCloseModelDropdownOnEscape","shouldCloseModelDropdownOnOutsideClick","shouldRegisterModelDropdownListeners","shouldRepositionModelDropdown","shouldUpdateSelectedAgentModel","VALIDATION_FIELDS_RULES","describe","it","expect","name","toBe","userPrompt","anchor","left","top","bottom","width","toEqual","placement","tightBottom","toMatchObject","tightAnchor","models","id","display_name","is_deprecated","aiModel","inputPlaceholder","introduction","emoji"],"sources":["../../../../src/components/molecules/AbmSection/AbmGeneralSection.helpers.spec.ts"],"sourcesContent":["import type { AgentModel } from '../../../types/agent'\nimport {\n  buildAbmGeneralFormValues,\n  computeModelDropdownHeight,\n  filterAvailableAgentModels,\n  MODEL_DROPDOWN_GAP,\n  MODEL_DROPDOWN_MAX_HEIGHT,\n  MODEL_OPTION_HEIGHT,\n  resolveDropdownPosition,\n  resolveModelDropdownToggleState,\n  shouldCloseModelDropdownOnEscape,\n  shouldCloseModelDropdownOnOutsideClick,\n  shouldRegisterModelDropdownListeners,\n  shouldRepositionModelDropdown,\n  shouldUpdateSelectedAgentModel,\n  VALIDATION_FIELDS_RULES,\n} from './AbmGeneralSection.helpers'\n\ndescribe('AbmGeneralSection.helpers', () => {\n  it('exposes validation limits for general fields', () => {\n    expect(VALIDATION_FIELDS_RULES.name).toBe(150)\n    expect(VALIDATION_FIELDS_RULES.userPrompt).toBe(5000)\n  })\n\n  describe('resolveDropdownPosition', () => {\n    const anchor = { left: 20, top: 100, bottom: 140, width: 300 }\n\n    it('opens below when there is enough space', () => {\n      expect(resolveDropdownPosition(anchor, 200, 800)).toEqual({\n        left: 20,\n        width: 300,\n        top: 140 + MODEL_DROPDOWN_GAP,\n        placement: 'bottom',\n      })\n    })\n\n    it('opens below when below space is larger than above even if tight', () => {\n      const tightBottom = { left: 10, top: 250, bottom: 290, width: 200 }\n      expect(resolveDropdownPosition(tightBottom, 200, 500)).toMatchObject({ placement: 'bottom', top: 294 })\n    })\n\n    it('opens above when there is more room on top', () => {\n      const tightAnchor = { left: 20, top: 400, bottom: 440, width: 300 }\n\n      expect(resolveDropdownPosition(tightAnchor, 400, 500)).toEqual({\n        left: 20,\n        width: 300,\n        bottom: 500 - 400 + MODEL_DROPDOWN_GAP,\n        placement: 'top',\n      })\n    })\n  })\n\n  describe('filterAvailableAgentModels', () => {\n    it('removes deprecated models', () => {\n      const models: AgentModel[] = [\n        { id: 1, display_name: 'Active' },\n        { id: 2, display_name: 'Legacy', is_deprecated: true },\n      ]\n\n      expect(filterAvailableAgentModels(models)).toEqual([models[0]])\n    })\n  })\n\n  describe('form and dropdown helpers', () => {\n    it('builds initial form values with defaults', () => {\n      expect(buildAbmGeneralFormValues({})).toEqual({\n        name: '',\n        aiModel: null,\n        inputPlaceholder: '',\n        introduction: '',\n        userPrompt: '',\n        emoji: '',\n      })\n      expect(\n        buildAbmGeneralFormValues({\n          name: 'Bot',\n          aiModel: { id: 1, display_name: 'GPT' },\n          inputPlaceholder: 'Ask',\n          introduction: 'Hi',\n          userPrompt: 'Help',\n          emoji: '🤖',\n        })\n      ).toMatchObject({ name: 'Bot', emoji: '🤖', userPrompt: 'Help' })\n    })\n\n    it('controls model dropdown interactions', () => {\n      expect(resolveModelDropdownToggleState(false)).toBe(true)\n      expect(shouldCloseModelDropdownOnOutsideClick(true, false, false)).toBe(true)\n      expect(shouldCloseModelDropdownOnOutsideClick(true, true, false)).toBe(false)\n      expect(shouldCloseModelDropdownOnEscape('Escape', true)).toBe(true)\n      expect(shouldCloseModelDropdownOnEscape('Enter', true)).toBe(false)\n      expect(shouldRegisterModelDropdownListeners(true)).toBe(true)\n      expect(shouldRepositionModelDropdown(false)).toBe(false)\n      expect(shouldUpdateSelectedAgentModel(1, 2)).toBe(true)\n      expect(shouldUpdateSelectedAgentModel(2, 2)).toBe(false)\n    })\n  })\n\n  describe('computeModelDropdownHeight', () => {\n    it('caps dropdown height to the configured maximum', () => {\n      expect(computeModelDropdownHeight(2)).toBe(2 * MODEL_OPTION_HEIGHT + 2)\n      expect(computeModelDropdownHeight(10)).toBe(MODEL_DROPDOWN_MAX_HEIGHT)\n    })\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/molecules/AbmSection/AbmGeneralSection.spec.js

@@ -0,0 +1,256 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { AbmGeneralSection } from './AbmGeneralSection';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+var handleSetAgentValues = jest.fn();
+var amplitudeEvent = jest.fn();
+var agentModels = [{
+  id: 1,
+  display_name: 'GPT 4',
+  keyword: 'smart'
+}, {
+  id: 3,
+  display_name: 'Claude',
+  keyword: 'fast'
+}, {
+  id: 2,
+  display_name: 'Legacy',
+  is_deprecated: true
+}];
+jest.mock('../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      selectModel: 'SELECT_MODEL',
+      chooseModel: 'CHOOSE_MODEL'
+    },
+    useEvent: function useEvent() {
+      return amplitudeEvent;
+    }
+  };
+});
+jest.mock('../../../hooks/useOnboardingNavigation', function () {
+  return {
+    useOnboardingNavigation: function useOnboardingNavigation() {
+      return {
+        handleOnboardingNavigation: jest.fn()
+      };
+    }
+  };
+});
+jest.mock('../../../hooks/useMaiaTaskPanelZIndex', function () {
+  return {
+    useMaiaTaskPanelZIndex: function useMaiaTaskPanelZIndex() {
+      return 1500;
+    }
+  };
+});
+jest.mock('../../../context/cor-user', function () {
+  return {
+    useUser: function useUser() {
+      return {
+        company_id: 10
+      };
+    }
+  };
+});
+jest.mock('@projectcor/emoji-reaction', function () {
+  return {
+    ButtonEmoji: function ButtonEmoji(_ref) {
+      var renderComponent = _ref.renderComponent,
+        onSelect = _ref.onSelect;
+      return /*#__PURE__*/_jsx("div", {
+        children: renderComponent({
+          iconRef: {
+            current: null
+          },
+          handleOpenSuggestionList: function handleOpenSuggestionList() {
+            return onSelect({
+              emoji: '🚀'
+            });
+          }
+        })
+      });
+    }
+  };
+});
+jest.mock('@projectcor/selector/lib/components/CUSelect', function () {
+  return {
+    CUSelect: function CUSelect(_ref2) {
+      var title = _ref2.title,
+        value = _ref2.value,
+        handleClickAction = _ref2.handleClickAction,
+        children = _ref2.children;
+      return /*#__PURE__*/_jsxs("button", {
+        type: "button",
+        "aria-label": title,
+        onClick: handleClickAction,
+        children: [value || 'select-model', children]
+      });
+    }
+  };
+});
+jest.mock('../../atoms/Input', function () {
+  return {
+    CustomInput: function CustomInput(_ref3) {
+      var label = _ref3.label,
+        value = _ref3.value,
+        _onChange = _ref3.onChange,
+        inputKey = _ref3.inputKey;
+      return /*#__PURE__*/_jsxs("label", {
+        htmlFor: "input-".concat(inputKey),
+        children: [label, /*#__PURE__*/_jsx("input", {
+          id: "input-".concat(inputKey),
+          "aria-label": inputKey,
+          value: value,
+          onChange: function onChange(event) {
+            return _onChange(event.target.value, inputKey);
+          }
+        })]
+      });
+    }
+  };
+});
+jest.mock('../../atoms/TextArea/CustomTextArea', function () {
+  return {
+    CustomTextArea: function CustomTextArea(_ref4) {
+      var label = _ref4.label,
+        value = _ref4.value,
+        handleChange = _ref4.handleChange,
+        inputKey = _ref4.inputKey;
+      return /*#__PURE__*/_jsxs("label", {
+        htmlFor: "textarea-".concat(inputKey),
+        children: [label, /*#__PURE__*/_jsx("textarea", {
+          id: "textarea-".concat(inputKey),
+          "aria-label": inputKey,
+          value: value,
+          onChange: function onChange(event) {
+            return handleChange(event.target.value, inputKey);
+          }
+        })]
+      });
+    }
+  };
+});
+var baseValues = {
+  isEditing: false,
+  knowledge: [],
+  general: {
+    name: 'Ventas',
+    emoji: '🤖',
+    introduction: '',
+    inputPlaceholder: '',
+    isActive: true,
+    aiModel: agentModels[0],
+    id: 1,
+    userPrompt: 'Ayuda con ventas',
+    knowledgeBases: []
+  },
+  accessibility: {
+    accessType: 'company'
+  }
+};
+describe('AbmGeneralSection', function () {
+  beforeEach(function () {
+    handleSetAgentValues.mockClear();
+    amplitudeEvent.mockClear();
+  });
+  it('updates general fields through handleSetAgentValues', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(AbmGeneralSection, {
+      values: baseValues,
+      handleSetAgentValues: handleSetAgentValues,
+      agentModels: agentModels,
+      loading: false
+    }));
+    fireEvent.change(screen.getByLabelText('name'), {
+      target: {
+        value: 'Soporte'
+      }
+    });
+    fireEvent.change(screen.getByLabelText('userPrompt'), {
+      target: {
+        value: 'Nuevo prompt'
+      }
+    });
+    expect(handleSetAgentValues).toHaveBeenCalledWith({
+      key: 'name',
+      value: 'Soporte'
+    });
+    expect(handleSetAgentValues).toHaveBeenCalledWith({
+      key: 'userPrompt',
+      value: 'Nuevo prompt'
+    });
+  });
+  it('opens the model dropdown and selects a non-deprecated model', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(AbmGeneralSection, {
+      values: baseValues,
+      handleSetAgentValues: handleSetAgentValues,
+      agentModels: agentModels,
+      loading: false
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'generalSection.modelAiLabel'
+    }));
+    expect(amplitudeEvent).toHaveBeenCalledWith('SELECT_MODEL');
+    var modelOptions = document.querySelectorAll('[data-selector-option]');
+    expect(modelOptions).toHaveLength(2);
+    expect(modelOptions[0]).toHaveTextContent('GPT 4');
+    expect(modelOptions[1]).toHaveTextContent('Claude');
+    expect(screen.queryByText('Legacy')).not.toBeInTheDocument();
+    fireEvent.click(screen.getByText('Claude'));
+    expect(handleSetAgentValues).toHaveBeenCalledWith({
+      key: 'aiModel',
+      value: agentModels[1]
+    });
+    expect(amplitudeEvent).toHaveBeenCalledWith('CHOOSE_MODEL', {
+      option: 'Claude'
+    });
+  });
+  it('closes the model dropdown when pressing Escape', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(AbmGeneralSection, {
+      values: baseValues,
+      handleSetAgentValues: handleSetAgentValues,
+      agentModels: agentModels,
+      loading: false
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'generalSection.modelAiLabel'
+    }));
+    expect(document.querySelectorAll('[data-selector-option]')).toHaveLength(2);
+    fireEvent.keyDown(document, {
+      key: 'Escape'
+    });
+    expect(document.querySelectorAll('[data-selector-option]')).toHaveLength(0);
+  });
+  it('selects emoji from the emoji picker', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(AbmGeneralSection, {
+      values: baseValues,
+      handleSetAgentValues: handleSetAgentValues,
+      agentModels: agentModels,
+      loading: false
+    }));
+    fireEvent.click(document.getElementById('abm-general-emoji-button'));
+    expect(handleSetAgentValues).toHaveBeenCalledWith({
+      key: 'emoji',
+      value: '🚀'
+    });
+  });
+  it('shows created-by metadata when present', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(AbmGeneralSection, {
+      values: _objectSpread(_objectSpread({}, baseValues), {}, {
+        general: _objectSpread(_objectSpread({}, baseValues.general), {}, {
+          created_by: {
+            name: 'Ana',
+            is_deleted: false
+          }
+        })
+      }),
+      handleSetAgentValues: handleSetAgentValues,
+      agentModels: agentModels,
+      loading: false
+    }));
+    expect(screen.getByText('Ana')).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","AbmGeneralSection","jsx","_jsx","jsxs","_jsxs","handleSetAgentValues","jest","fn","amplitudeEvent","agentModels","id","display_name","keyword","is_deprecated","mock","EVENTS","selectModel","chooseModel","useEvent","useOnboardingNavigation","handleOnboardingNavigation","useMaiaTaskPanelZIndex","useUser","company_id","ButtonEmoji","_ref","renderComponent","onSelect","children","iconRef","current","handleOpenSuggestionList","emoji","CUSelect","_ref2","title","value","handleClickAction","type","onClick","CustomInput","_ref3","label","onChange","inputKey","htmlFor","concat","event","target","CustomTextArea","_ref4","handleChange","baseValues","isEditing","knowledge","general","name","introduction","inputPlaceholder","isActive","aiModel","userPrompt","knowledgeBases","accessibility","accessType","describe","beforeEach","mockClear","it","values","loading","change","getByLabelText","expect","toHaveBeenCalledWith","key","click","getByRole","modelOptions","document","querySelectorAll","toHaveLength","toHaveTextContent","queryByText","not","toBeInTheDocument","getByText","option","keyDown","getElementById","_objectSpread","created_by","is_deleted"],"sources":["../../../../src/components/molecules/AbmSection/AbmGeneralSection.spec.tsx"],"sourcesContent":["import type { ReactNode } from 'react'\nimport { fireEvent, renderWithProviders, screen } from '../../../test/test-utils'\nimport type { AgentModel } from '../../../types/agent'\nimport type { ModalValues } from '../../../types/agentModal'\nimport { AbmGeneralSection } from './AbmGeneralSection'\n\nconst handleSetAgentValues = jest.fn()\nconst amplitudeEvent = jest.fn()\n\nconst agentModels: AgentModel[] = [\n  { id: 1, display_name: 'GPT 4', keyword: 'smart' },\n  { id: 3, display_name: 'Claude', keyword: 'fast' },\n  { id: 2, display_name: 'Legacy', is_deprecated: true },\n]\n\njest.mock('../../../hooks/useEvent', () => ({\n  EVENTS: { selectModel: 'SELECT_MODEL', chooseModel: 'CHOOSE_MODEL' },\n  useEvent: () => amplitudeEvent,\n}))\n\njest.mock('../../../hooks/useOnboardingNavigation', () => ({\n  useOnboardingNavigation: () => ({ handleOnboardingNavigation: jest.fn() }),\n}))\n\njest.mock('../../../hooks/useMaiaTaskPanelZIndex', () => ({\n  useMaiaTaskPanelZIndex: () => 1500,\n}))\n\njest.mock('../../../context/cor-user', () => ({\n  useUser: () => ({ company_id: 10 }),\n}))\n\njest.mock('@projectcor/emoji-reaction', () => ({\n  ButtonEmoji: ({\n    renderComponent,\n    onSelect,\n  }: {\n    renderComponent: (args: { iconRef: { current: null }; handleOpenSuggestionList: () => void }) => ReactNode\n    onSelect: (payload: { emoji: string }) => void\n  }) => (\n    <div>\n      {renderComponent({ iconRef: { current: null }, handleOpenSuggestionList: () => onSelect({ emoji: '🚀' }) })}\n    </div>\n  ),\n}))\n\njest.mock('@projectcor/selector/lib/components/CUSelect', () => ({\n  CUSelect: ({\n    title,\n    value,\n    handleClickAction,\n    children,\n  }: {\n    title: string\n    value?: string\n    handleClickAction: () => void\n    children: ReactNode\n  }) => (\n    <button type=\"button\" aria-label={title} onClick={handleClickAction}>\n      {value || 'select-model'}\n      {children}\n    </button>\n  ),\n}))\n\njest.mock('../../atoms/Input', () => ({\n  CustomInput: ({\n    label,\n    value,\n    onChange,\n    inputKey,\n  }: {\n    label: string\n    value: string\n    onChange: (value: string, key: string) => void\n    inputKey: string\n  }) => (\n    <label htmlFor={`input-${inputKey}`}>\n      {label}\n      <input\n        id={`input-${inputKey}`}\n        aria-label={inputKey}\n        value={value}\n        onChange={event => onChange(event.target.value, inputKey)}\n      />\n    </label>\n  ),\n}))\n\njest.mock('../../atoms/TextArea/CustomTextArea', () => ({\n  CustomTextArea: ({\n    label,\n    value,\n    handleChange,\n    inputKey,\n  }: {\n    label: string\n    value: string\n    handleChange: (value: string, key: string) => void\n    inputKey: string\n  }) => (\n    <label htmlFor={`textarea-${inputKey}`}>\n      {label}\n      <textarea\n        id={`textarea-${inputKey}`}\n        aria-label={inputKey}\n        value={value}\n        onChange={event => handleChange(event.target.value, inputKey)}\n      />\n    </label>\n  ),\n}))\n\nconst baseValues: ModalValues = {\n  isEditing: false,\n  knowledge: [],\n  general: {\n    name: 'Ventas',\n    emoji: '🤖',\n    introduction: '',\n    inputPlaceholder: '',\n    isActive: true,\n    aiModel: agentModels[0],\n    id: 1,\n    userPrompt: 'Ayuda con ventas',\n    knowledgeBases: [],\n  },\n  accessibility: { accessType: 'company' },\n}\n\ndescribe('AbmGeneralSection', () => {\n  beforeEach(() => {\n    handleSetAgentValues.mockClear()\n    amplitudeEvent.mockClear()\n  })\n\n  it('updates general fields through handleSetAgentValues', () => {\n    renderWithProviders(\n      <AbmGeneralSection\n        values={baseValues}\n        handleSetAgentValues={handleSetAgentValues}\n        agentModels={agentModels}\n        loading={false}\n      />\n    )\n\n    fireEvent.change(screen.getByLabelText('name'), { target: { value: 'Soporte' } })\n    fireEvent.change(screen.getByLabelText('userPrompt'), { target: { value: 'Nuevo prompt' } })\n\n    expect(handleSetAgentValues).toHaveBeenCalledWith({ key: 'name', value: 'Soporte' })\n    expect(handleSetAgentValues).toHaveBeenCalledWith({ key: 'userPrompt', value: 'Nuevo prompt' })\n  })\n\n  it('opens the model dropdown and selects a non-deprecated model', () => {\n    renderWithProviders(\n      <AbmGeneralSection\n        values={baseValues}\n        handleSetAgentValues={handleSetAgentValues}\n        agentModels={agentModels}\n        loading={false}\n      />\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'generalSection.modelAiLabel' }))\n    expect(amplitudeEvent).toHaveBeenCalledWith('SELECT_MODEL')\n\n    const modelOptions = document.querySelectorAll('[data-selector-option]')\n    expect(modelOptions).toHaveLength(2)\n    expect(modelOptions[0]).toHaveTextContent('GPT 4')\n    expect(modelOptions[1]).toHaveTextContent('Claude')\n    expect(screen.queryByText('Legacy')).not.toBeInTheDocument()\n\n    fireEvent.click(screen.getByText('Claude'))\n    expect(handleSetAgentValues).toHaveBeenCalledWith({ key: 'aiModel', value: agentModels[1] })\n    expect(amplitudeEvent).toHaveBeenCalledWith('CHOOSE_MODEL', { option: 'Claude' })\n  })\n\n  it('closes the model dropdown when pressing Escape', () => {\n    renderWithProviders(\n      <AbmGeneralSection\n        values={baseValues}\n        handleSetAgentValues={handleSetAgentValues}\n        agentModels={agentModels}\n        loading={false}\n      />\n    )\n\n    fireEvent.click(screen.getByRole('button', { name: 'generalSection.modelAiLabel' }))\n    expect(document.querySelectorAll('[data-selector-option]')).toHaveLength(2)\n\n    fireEvent.keyDown(document, { key: 'Escape' })\n    expect(document.querySelectorAll('[data-selector-option]')).toHaveLength(0)\n  })\n\n  it('selects emoji from the emoji picker', () => {\n    renderWithProviders(\n      <AbmGeneralSection\n        values={baseValues}\n        handleSetAgentValues={handleSetAgentValues}\n        agentModels={agentModels}\n        loading={false}\n      />\n    )\n\n    fireEvent.click(document.getElementById('abm-general-emoji-button')!)\n    expect(handleSetAgentValues).toHaveBeenCalledWith({ key: 'emoji', value: '🚀' })\n  })\n\n  it('shows created-by metadata when present', () => {\n    renderWithProviders(\n      <AbmGeneralSection\n        values={{\n          ...baseValues,\n          general: {\n            ...baseValues.general,\n            created_by: { name: 'Ana', is_deleted: false },\n          },\n        }}\n        handleSetAgentValues={handleSetAgentValues}\n        agentModels={agentModels}\n        loading={false}\n      />\n    )\n\n    expect(screen.getByText('Ana')).toBeInTheDocument()\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/molecules/AbmSection/AbmKnowledgeSection.helpers.spec.js

@@ -0,0 +1,175 @@
+import { appendKnowledgeAttachments, canPreviewKnowledgeAttachment, computeAttachmentsTotalSize, createClosedKnowledgeFileErrorModalState, getUniqueString, processKnowledgeFiles, removeKnowledgeAttachmentByIndex, resolveKnowledgeAttachmentAtIndex, resolveKnowledgeFileErrorModalState, shouldBlockKnowledgeUpload, shouldEnableKnowledgeDragState, shouldHandleKnowledgeAttachmentAction, shouldProcessKnowledgeFileInput, shouldRunKnowledgeDownloadEffect } from './AbmKnowledgeSection.helpers';
+var makeFile = function makeFile(name, size) {
+  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'text/plain';
+  return new File(['x'.repeat(size)], name, {
+    type: type
+  });
+};
+describe('AbmKnowledgeSection.helpers', function () {
+  describe('getUniqueString', function () {
+    it('returns the original name when it is available', function () {
+      expect(getUniqueString(['other.pdf'], 'manual.pdf')).toBe('manual.pdf');
+    });
+    it('appends a counter when the name already exists', function () {
+      expect(getUniqueString(['manual.pdf'], 'manual.pdf')).toBe('manual(1).pdf');
+      expect(getUniqueString(['manual.pdf', 'manual(1).pdf'], 'manual.pdf')).toBe('manual(2).pdf');
+    });
+  });
+  describe('computeAttachmentsTotalSize', function () {
+    it('sums numeric sizes and ignores invalid values', function () {
+      expect(computeAttachmentsTotalSize([{
+        size: 100
+      }, {
+        size: '50'
+      }, {
+        size: Number.NaN
+      }])).toBe(150);
+    });
+  });
+  describe('processKnowledgeFiles', function () {
+    it('accepts valid files within the total size limit', function () {
+      var result = processKnowledgeFiles({
+        files: [makeFile('notes.txt', 1024)],
+        existingAttachments: [],
+        allowedExtensions: ['.txt'],
+        fileTypes: {
+          '.txt': 'text/plain'
+        },
+        createId: function createId() {
+          return 'file-1';
+        }
+      });
+      expect(result.hasErrors).toBe(false);
+      expect(result.insertedFiles).toHaveLength(1);
+      expect(result.insertedFiles[0]).toMatchObject({
+        name: 'notes.txt',
+        status: 'started'
+      });
+    });
+    it('rejects invalid extensions and files that exceed the total limit', function () {
+      var result = processKnowledgeFiles({
+        files: [makeFile('bad.exe', 100), makeFile('big.txt', 200)],
+        existingAttachments: [],
+        allowedExtensions: ['.txt'],
+        fileTypes: {
+          '.txt': 'text/plain'
+        },
+        maxTotalSize: 100
+      });
+      expect(result.invalidExtensionFiles).toEqual(['bad.exe']);
+      expect(result.exceededFiles).toEqual(['big.txt']);
+      expect(result.hasErrors).toBe(true);
+      expect(result.insertedFiles).toHaveLength(0);
+    });
+    it('deduplicates file names against existing attachments', function () {
+      var _result$insertedFiles;
+      var existingFile = makeFile('notes.txt', 100);
+      var result = processKnowledgeFiles({
+        files: [makeFile('notes.txt', 100)],
+        existingAttachments: [{
+          id: '1',
+          name: 'notes.txt',
+          size: 100,
+          type: 'text/plain',
+          file: existingFile,
+          status: 'done'
+        }],
+        allowedExtensions: ['.txt'],
+        fileTypes: {
+          '.txt': 'text/plain'
+        },
+        createId: function createId() {
+          return 'file-2';
+        }
+      });
+      expect((_result$insertedFiles = result.insertedFiles[0]) === null || _result$insertedFiles === void 0 ? void 0 : _result$insertedFiles.name).toBe('notes(1).txt');
+    });
+  });
+  describe('upload interaction helpers', function () {
+    it('guards upload, drag and file input processing', function () {
+      expect(shouldBlockKnowledgeUpload(true)).toBe(true);
+      expect(shouldEnableKnowledgeDragState(true)).toBe(false);
+      expect(shouldProcessKnowledgeFileInput(null)).toBe(false);
+      expect(shouldProcessKnowledgeFileInput({
+        length: 1
+      })).toBe(true);
+      expect(shouldHandleKnowledgeAttachmentAction(true)).toBe(false);
+    });
+    it('merges attachments and resolves indices', function () {
+      var attachment = {
+        id: '1',
+        name: 'a.pdf',
+        size: 1,
+        type: 'application/pdf',
+        file: makeFile('a.pdf', 1, 'application/pdf')
+      };
+      expect(appendKnowledgeAttachments([], [attachment])).toHaveLength(1);
+      expect(appendKnowledgeAttachments(null, [attachment])).toHaveLength(1);
+      expect(removeKnowledgeAttachmentByIndex([attachment], 0)).toEqual([]);
+      expect(removeKnowledgeAttachmentByIndex([attachment], 3)).toBeNull();
+      expect(resolveKnowledgeAttachmentAtIndex([attachment], 0)).toEqual(attachment);
+      expect(resolveKnowledgeAttachmentAtIndex([attachment], 9)).toBeNull();
+    });
+    it('builds modal states and download effect guard', function () {
+      expect(resolveKnowledgeFileErrorModalState({
+        exceededFiles: ['a'],
+        invalidExtensionFiles: ['b']
+      })).toMatchObject({
+        isOpen: true,
+        exceededFiles: ['a']
+      });
+      expect(createClosedKnowledgeFileErrorModalState()).toMatchObject({
+        isOpen: false
+      });
+      expect(shouldRunKnowledgeDownloadEffect({
+        blob: new Blob([]),
+        filename: 'a.pdf'
+      }, null, false)).toBe(true);
+      expect(shouldRunKnowledgeDownloadEffect(null, 'err', false)).toBe(false);
+    });
+  });
+  describe('canPreviewKnowledgeAttachment', function () {
+    it('allows preview for local files and rejects failed uploads', function () {
+      expect(canPreviewKnowledgeAttachment({
+        id: '1',
+        name: 'a.pdf',
+        size: 1,
+        type: 'application/pdf',
+        file: makeFile('a.pdf', 1, 'application/pdf')
+      })).toBe(true);
+      expect(canPreviewKnowledgeAttachment({
+        id: '2',
+        name: 'b.pdf',
+        size: 1,
+        type: 'application/pdf',
+        status: 'failed',
+        file: makeFile('b.pdf', 1, 'application/pdf')
+      })).toBe(false);
+      expect(canPreviewKnowledgeAttachment({
+        id: '3',
+        name: 'remote.pdf',
+        size: 1,
+        type: 'application/pdf',
+        url_original: 'https://cdn/remote.pdf'
+      })).toBe(true);
+      expect(canPreviewKnowledgeAttachment({
+        id: '4',
+        name: 'thumb.pdf',
+        size: 1,
+        type: 'application/pdf',
+        url_thumbnail: 'https://cdn/thumb.png'
+      })).toBe(true);
+      expect(canPreviewKnowledgeAttachment({
+        id: '5',
+        name: 'local-copy.pdf',
+        size: 1,
+        type: 'application/pdf',
+        originalFile: makeFile('local-copy.pdf', 1, 'application/pdf')
+      })).toBe(true);
+    });
+    it('deduplicates names without extension', function () {
+      expect(getUniqueString(['readme'], 'readme')).toBe('readme(1)');
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["appendKnowledgeAttachments","canPreviewKnowledgeAttachment","computeAttachmentsTotalSize","createClosedKnowledgeFileErrorModalState","getUniqueString","processKnowledgeFiles","removeKnowledgeAttachmentByIndex","resolveKnowledgeAttachmentAtIndex","resolveKnowledgeFileErrorModalState","shouldBlockKnowledgeUpload","shouldEnableKnowledgeDragState","shouldHandleKnowledgeAttachmentAction","shouldProcessKnowledgeFileInput","shouldRunKnowledgeDownloadEffect","makeFile","name","size","type","arguments","length","undefined","File","repeat","describe","it","expect","toBe","Number","NaN","result","files","existingAttachments","allowedExtensions","fileTypes","createId","hasErrors","insertedFiles","toHaveLength","toMatchObject","status","maxTotalSize","invalidExtensionFiles","toEqual","exceededFiles","_result$insertedFiles","existingFile","id","file","attachment","toBeNull","isOpen","blob","Blob","filename","url_original","url_thumbnail","originalFile"],"sources":["../../../../src/components/molecules/AbmSection/AbmKnowledgeSection.helpers.spec.ts"],"sourcesContent":["import {\n  appendKnowledgeAttachments,\n  canPreviewKnowledgeAttachment,\n  computeAttachmentsTotalSize,\n  createClosedKnowledgeFileErrorModalState,\n  getUniqueString,\n  processKnowledgeFiles,\n  removeKnowledgeAttachmentByIndex,\n  resolveKnowledgeAttachmentAtIndex,\n  resolveKnowledgeFileErrorModalState,\n  shouldBlockKnowledgeUpload,\n  shouldEnableKnowledgeDragState,\n  shouldHandleKnowledgeAttachmentAction,\n  shouldProcessKnowledgeFileInput,\n  shouldRunKnowledgeDownloadEffect,\n} from './AbmKnowledgeSection.helpers'\n\nconst makeFile = (name: string, size: number, type = 'text/plain') => new File(['x'.repeat(size)], name, { type })\n\ndescribe('AbmKnowledgeSection.helpers', () => {\n  describe('getUniqueString', () => {\n    it('returns the original name when it is available', () => {\n      expect(getUniqueString(['other.pdf'], 'manual.pdf')).toBe('manual.pdf')\n    })\n\n    it('appends a counter when the name already exists', () => {\n      expect(getUniqueString(['manual.pdf'], 'manual.pdf')).toBe('manual(1).pdf')\n      expect(getUniqueString(['manual.pdf', 'manual(1).pdf'], 'manual.pdf')).toBe('manual(2).pdf')\n    })\n  })\n\n  describe('computeAttachmentsTotalSize', () => {\n    it('sums numeric sizes and ignores invalid values', () => {\n      expect(\n        computeAttachmentsTotalSize([{ size: 100 }, { size: '50' as unknown as number }, { size: Number.NaN }])\n      ).toBe(150)\n    })\n  })\n\n  describe('processKnowledgeFiles', () => {\n    it('accepts valid files within the total size limit', () => {\n      const result = processKnowledgeFiles({\n        files: [makeFile('notes.txt', 1024)],\n        existingAttachments: [],\n        allowedExtensions: ['.txt'],\n        fileTypes: { '.txt': 'text/plain' },\n        createId: () => 'file-1',\n      })\n\n      expect(result.hasErrors).toBe(false)\n      expect(result.insertedFiles).toHaveLength(1)\n      expect(result.insertedFiles[0]).toMatchObject({ name: 'notes.txt', status: 'started' })\n    })\n\n    it('rejects invalid extensions and files that exceed the total limit', () => {\n      const result = processKnowledgeFiles({\n        files: [makeFile('bad.exe', 100), makeFile('big.txt', 200)],\n        existingAttachments: [],\n        allowedExtensions: ['.txt'],\n        fileTypes: { '.txt': 'text/plain' },\n        maxTotalSize: 100,\n      })\n\n      expect(result.invalidExtensionFiles).toEqual(['bad.exe'])\n      expect(result.exceededFiles).toEqual(['big.txt'])\n      expect(result.hasErrors).toBe(true)\n      expect(result.insertedFiles).toHaveLength(0)\n    })\n\n    it('deduplicates file names against existing attachments', () => {\n      const existingFile = makeFile('notes.txt', 100)\n      const result = processKnowledgeFiles({\n        files: [makeFile('notes.txt', 100)],\n        existingAttachments: [\n          {\n            id: '1',\n            name: 'notes.txt',\n            size: 100,\n            type: 'text/plain',\n            file: existingFile,\n            status: 'done',\n          },\n        ],\n        allowedExtensions: ['.txt'],\n        fileTypes: { '.txt': 'text/plain' },\n        createId: () => 'file-2',\n      })\n\n      expect(result.insertedFiles[0]?.name).toBe('notes(1).txt')\n    })\n  })\n\n  describe('upload interaction helpers', () => {\n    it('guards upload, drag and file input processing', () => {\n      expect(shouldBlockKnowledgeUpload(true)).toBe(true)\n      expect(shouldEnableKnowledgeDragState(true)).toBe(false)\n      expect(shouldProcessKnowledgeFileInput(null)).toBe(false)\n      expect(shouldProcessKnowledgeFileInput({ length: 1 } as FileList)).toBe(true)\n      expect(shouldHandleKnowledgeAttachmentAction(true)).toBe(false)\n    })\n\n    it('merges attachments and resolves indices', () => {\n      const attachment = {\n        id: '1',\n        name: 'a.pdf',\n        size: 1,\n        type: 'application/pdf',\n        file: makeFile('a.pdf', 1, 'application/pdf'),\n      }\n      expect(appendKnowledgeAttachments([], [attachment])).toHaveLength(1)\n      expect(appendKnowledgeAttachments(null as unknown as [], [attachment])).toHaveLength(1)\n      expect(removeKnowledgeAttachmentByIndex([attachment], 0)).toEqual([])\n      expect(removeKnowledgeAttachmentByIndex([attachment], 3)).toBeNull()\n      expect(resolveKnowledgeAttachmentAtIndex([attachment], 0)).toEqual(attachment)\n      expect(resolveKnowledgeAttachmentAtIndex([attachment], 9)).toBeNull()\n    })\n\n    it('builds modal states and download effect guard', () => {\n      expect(resolveKnowledgeFileErrorModalState({ exceededFiles: ['a'], invalidExtensionFiles: ['b'] })).toMatchObject(\n        {\n          isOpen: true,\n          exceededFiles: ['a'],\n        }\n      )\n      expect(createClosedKnowledgeFileErrorModalState()).toMatchObject({ isOpen: false })\n      expect(shouldRunKnowledgeDownloadEffect({ blob: new Blob([]), filename: 'a.pdf' }, null, false)).toBe(true)\n      expect(shouldRunKnowledgeDownloadEffect(null, 'err', false)).toBe(false)\n    })\n  })\n\n  describe('canPreviewKnowledgeAttachment', () => {\n    it('allows preview for local files and rejects failed uploads', () => {\n      expect(\n        canPreviewKnowledgeAttachment({\n          id: '1',\n          name: 'a.pdf',\n          size: 1,\n          type: 'application/pdf',\n          file: makeFile('a.pdf', 1, 'application/pdf'),\n        })\n      ).toBe(true)\n\n      expect(\n        canPreviewKnowledgeAttachment({\n          id: '2',\n          name: 'b.pdf',\n          size: 1,\n          type: 'application/pdf',\n          status: 'failed',\n          file: makeFile('b.pdf', 1, 'application/pdf'),\n        })\n      ).toBe(false)\n\n      expect(\n        canPreviewKnowledgeAttachment({\n          id: '3',\n          name: 'remote.pdf',\n          size: 1,\n          type: 'application/pdf',\n          url_original: 'https://cdn/remote.pdf',\n        })\n      ).toBe(true)\n\n      expect(\n        canPreviewKnowledgeAttachment({\n          id: '4',\n          name: 'thumb.pdf',\n          size: 1,\n          type: 'application/pdf',\n          url_thumbnail: 'https://cdn/thumb.png',\n        })\n      ).toBe(true)\n\n      expect(\n        canPreviewKnowledgeAttachment({\n          id: '5',\n          name: 'local-copy.pdf',\n          size: 1,\n          type: 'application/pdf',\n          originalFile: makeFile('local-copy.pdf', 1, 'application/pdf'),\n        })\n      ).toBe(true)\n    })\n\n    it('deduplicates names without extension', () => {\n      expect(getUniqueString(['readme'], 'readme')).toBe('readme(1)')\n    })\n  })\n})\n"],"mappings":"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","ignoreList":[]}