@projectcor/maia-components 2.49.0 → 2.49.1-1

package/lib/components/atoms/SlashCommandDropdown/SlashCommandDropdown.spec.js

@@ -0,0 +1,120 @@
+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 { SlashCommandDropdown } from './SlashCommandDropdown';
+import { jsx as _jsx } from "react/jsx-runtime";
+var action = function action(overrides) {
+  return _objectSpread({
+    id: '1',
+    title: 'Crear tarea',
+    subtitle: 'Nueva tarea',
+    prompt: 'p',
+    language: null,
+    category: 'tasks'
+  }, overrides);
+};
+var commands = [action({
+  id: 'task',
+  title: 'Crear tarea',
+  category: 'tasks'
+}), action({
+  id: 'hours',
+  title: 'Cargar horas',
+  subtitle: 'Esta semana',
+  category: 'hours'
+})];
+describe('SlashCommandDropdown', function () {
+  var onSelect = jest.fn();
+  var onClose = jest.fn();
+  beforeEach(function () {
+    onSelect.mockClear();
+    onClose.mockClear();
+  });
+  it('filters commands by query and selects one', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(SlashCommandDropdown, {
+      commands: commands,
+      query: "horas",
+      onSelect: onSelect,
+      onClose: onClose,
+      bottom: 0,
+      left: 0
+    }));
+    var hoursButton = screen.getByRole('button', {
+      name: /Cargar horas/
+    });
+    expect(hoursButton).toBeInTheDocument();
+    expect(screen.queryByRole('button', {
+      name: /Crear tarea/
+    })).not.toBeInTheDocument();
+    fireEvent.click(hoursButton);
+    expect(onSelect).toHaveBeenCalledWith(expect.objectContaining({
+      id: 'hours'
+    }));
+  });
+  it('closes on Escape and outside click', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(SlashCommandDropdown, {
+      commands: commands,
+      query: "",
+      onSelect: onSelect,
+      onClose: onClose,
+      bottom: 0,
+      left: 0
+    }));
+    fireEvent.keyDown(document, {
+      key: 'Escape'
+    });
+    expect(onClose).toHaveBeenCalled();
+    onClose.mockClear();
+    fireEvent.mouseDown(document.body);
+    expect(onClose).toHaveBeenCalled();
+  });
+  it('returns null when nothing matches', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(SlashCommandDropdown, {
+        commands: commands,
+        query: "zzz",
+        onSelect: onSelect,
+        onClose: onClose,
+        bottom: 0,
+        left: 0
+      })),
+      container = _renderWithProviders.container;
+    expect(container).toBeEmptyDOMElement();
+  });
+  it('navigates with arrow keys and selects on Enter', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(SlashCommandDropdown, {
+      commands: commands,
+      query: "",
+      onSelect: onSelect,
+      onClose: onClose,
+      bottom: 0,
+      left: 0
+    }));
+    fireEvent.keyDown(document, {
+      key: 'ArrowDown'
+    });
+    fireEvent.keyDown(document, {
+      key: 'Enter'
+    });
+    expect(onSelect).toHaveBeenCalledWith(expect.objectContaining({
+      id: 'hours'
+    }));
+  });
+  it('does not close when clicking inside the anchor ref', function () {
+    var anchorRef = {
+      current: document.createElement('div')
+    };
+    renderWithProviders(/*#__PURE__*/_jsx(SlashCommandDropdown, {
+      commands: commands,
+      query: "",
+      onSelect: onSelect,
+      onClose: onClose,
+      bottom: 0,
+      left: 0,
+      anchorRef: anchorRef
+    }));
+    fireEvent.mouseDown(anchorRef.current);
+    expect(onClose).not.toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","SlashCommandDropdown","jsx","_jsx","action","overrides","_objectSpread","id","title","subtitle","prompt","language","category","commands","describe","onSelect","jest","fn","onClose","beforeEach","mockClear","it","query","bottom","left","hoursButton","getByRole","name","expect","toBeInTheDocument","queryByRole","not","click","toHaveBeenCalledWith","objectContaining","keyDown","document","key","toHaveBeenCalled","mouseDown","body","_renderWithProviders","container","toBeEmptyDOMElement","anchorRef","current","createElement"],"sources":["../../../../src/components/atoms/SlashCommandDropdown/SlashCommandDropdown.spec.tsx"],"sourcesContent":["import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils'\nimport type { Action } from '../../../types/Action'\nimport { SlashCommandDropdown } from './SlashCommandDropdown'\n\nconst action = (overrides: Partial<Action>): Action => ({\n  id: '1',\n  title: 'Crear tarea',\n  subtitle: 'Nueva tarea',\n  prompt: 'p',\n  language: null,\n  category: 'tasks',\n  ...overrides,\n})\n\nconst commands = [\n  action({ id: 'task', title: 'Crear tarea', category: 'tasks' }),\n  action({ id: 'hours', title: 'Cargar horas', subtitle: 'Esta semana', category: 'hours' }),\n]\n\ndescribe('SlashCommandDropdown', () => {\n  const onSelect = jest.fn()\n  const onClose = jest.fn()\n\n  beforeEach(() => {\n    onSelect.mockClear()\n    onClose.mockClear()\n  })\n\n  it('filters commands by query and selects one', () => {\n    renderWithProviders(\n      <SlashCommandDropdown\n        commands={commands}\n        query=\"horas\"\n        onSelect={onSelect}\n        onClose={onClose}\n        bottom={0}\n        left={0}\n      />\n    )\n\n    const hoursButton = screen.getByRole('button', { name: /Cargar horas/ })\n    expect(hoursButton).toBeInTheDocument()\n    expect(screen.queryByRole('button', { name: /Crear tarea/ })).not.toBeInTheDocument()\n\n    fireEvent.click(hoursButton)\n    expect(onSelect).toHaveBeenCalledWith(expect.objectContaining({ id: 'hours' }))\n  })\n\n  it('closes on Escape and outside click', () => {\n    renderWithProviders(\n      <SlashCommandDropdown commands={commands} query=\"\" onSelect={onSelect} onClose={onClose} bottom={0} left={0} />\n    )\n\n    fireEvent.keyDown(document, { key: 'Escape' })\n    expect(onClose).toHaveBeenCalled()\n\n    onClose.mockClear()\n    fireEvent.mouseDown(document.body)\n    expect(onClose).toHaveBeenCalled()\n  })\n\n  it('returns null when nothing matches', () => {\n    const { container } = renderWithProviders(\n      <SlashCommandDropdown commands={commands} query=\"zzz\" onSelect={onSelect} onClose={onClose} bottom={0} left={0} />\n    )\n\n    expect(container).toBeEmptyDOMElement()\n  })\n\n  it('navigates with arrow keys and selects on Enter', () => {\n    renderWithProviders(\n      <SlashCommandDropdown commands={commands} query=\"\" onSelect={onSelect} onClose={onClose} bottom={0} left={0} />\n    )\n\n    fireEvent.keyDown(document, { key: 'ArrowDown' })\n    fireEvent.keyDown(document, { key: 'Enter' })\n\n    expect(onSelect).toHaveBeenCalledWith(expect.objectContaining({ id: 'hours' }))\n  })\n\n  it('does not close when clicking inside the anchor ref', () => {\n    const anchorRef = { current: document.createElement('div') }\n    renderWithProviders(\n      <SlashCommandDropdown\n        commands={commands}\n        query=\"\"\n        onSelect={onSelect}\n        onClose={onClose}\n        bottom={0}\n        left={0}\n        anchorRef={anchorRef}\n      />\n    )\n\n    fireEvent.mouseDown(anchorRef.current)\n    expect(onClose).not.toHaveBeenCalled()\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/atoms/Switch/Switch.spec.js

@@ -0,0 +1,41 @@
+import { renderWithProviders, screen } from '../../../test/test-utils';
+import { Switch } from './Switch';
+import { jsx as _jsx } from "react/jsx-runtime";
+describe('Switch', function () {
+  it('exposes the checked state to assistive tech', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(Switch, {
+      checked: true,
+      "aria-label": "Auto approve",
+      onChange: jest.fn()
+    }));
+    expect(screen.getByRole('switch', {
+      name: 'Auto approve'
+    })).toHaveAttribute('aria-checked', 'true');
+  });
+  it('calls onChange with the opposite value', function () {
+    var onChange = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(Switch, {
+      checked: false,
+      "aria-label": "Auto approve",
+      onChange: onChange
+    }));
+    screen.getByRole('switch', {
+      name: 'Auto approve'
+    }).click();
+    expect(onChange).toHaveBeenCalledWith(true);
+  });
+  it('does not call onChange when disabled', function () {
+    var onChange = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(Switch, {
+      checked: false,
+      disabled: true,
+      "aria-label": "Auto approve",
+      onChange: onChange
+    }));
+    screen.getByRole('switch', {
+      name: 'Auto approve'
+    }).click();
+    expect(onChange).not.toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/atoms/TextArea/CustomTextArea.spec.js

@@ -0,0 +1,52 @@
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { CustomTextArea } from './CustomTextArea';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('./TextArea', function () {
+  return {
+    TextArea: function TextArea(_ref) {
+      var value = _ref.value,
+        onChange = _ref.onChange,
+        onBlur = _ref.onBlur,
+        placeholder = _ref.placeholder;
+      return /*#__PURE__*/_jsx("textarea", {
+        "aria-label": "custom-textarea",
+        value: value,
+        placeholder: placeholder,
+        onChange: onChange,
+        onBlur: onBlur
+      });
+    }
+  };
+});
+describe('CustomTextArea', function () {
+  it('trims on blur when isTrimmed is enabled', function () {
+    var handleChange = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(CustomTextArea, {
+      value: "  hello  ",
+      inputKey: "intro",
+      handleChange: handleChange,
+      handleBlur: jest.fn(),
+      isTrimmed: true,
+      maxLength: 100
+    }));
+    fireEvent.blur(screen.getByLabelText('custom-textarea'));
+    expect(handleChange).toHaveBeenCalledWith('hello', 'intro');
+  });
+  it('shows an error when max length is exceeded', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(CustomTextArea, {
+      value: "",
+      inputKey: "intro",
+      handleChange: jest.fn(),
+      maxLength: 3,
+      label: "Intro",
+      errorMessage: "Too long"
+    }));
+    fireEvent.change(screen.getByLabelText('custom-textarea'), {
+      target: {
+        value: 'abcd'
+      }
+    });
+    expect(screen.getByText('Too long')).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/atoms/TextArea/TextArea.helpers.spec.js

@@ -0,0 +1,25 @@
+import { resolveTextAreaHeight, resolveTextAreaOverflow, resolveTextAreaScrollAfterGrowth, shouldAdjustScrollOnGrowth, shouldAutoResizeTextArea, shouldForceMinHeightOnClear, shouldRunPasteAutoResize } from './TextArea.helpers';
+describe('TextArea.helpers', function () {
+  it('detects clear and growth resize triggers', function () {
+    expect(shouldForceMinHeightOnClear(true, '')).toBe(true);
+    expect(shouldForceMinHeightOnClear(false, '')).toBe(false);
+    expect(shouldAdjustScrollOnGrowth(true, 'abc', 1)).toBe(true);
+    expect(shouldAdjustScrollOnGrowth(true, 'ab', 2)).toBe(false);
+  });
+  it('resolves scroll position after growth', function () {
+    expect(resolveTextAreaScrollAfterGrowth(9, 10, 200, 5)).toBe(200);
+    expect(resolveTextAreaScrollAfterGrowth(2, 10, 200, 5)).toBe(5);
+  });
+  it('computes height and overflow', function () {
+    expect(resolveTextAreaHeight(30, 44, 280)).toBe(44);
+    expect(resolveTextAreaHeight(400, 44, 280)).toBe(280);
+    expect(resolveTextAreaOverflow(400, 280)).toBe('auto');
+    expect(resolveTextAreaOverflow(100, 280)).toBe('hidden');
+  });
+  it('guards auto resize helpers', function () {
+    expect(shouldAutoResizeTextArea(true, document.createElement('textarea'))).toBe(true);
+    expect(shouldAutoResizeTextArea(false, document.createElement('textarea'))).toBe(false);
+    expect(shouldRunPasteAutoResize(true)).toBe(true);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/atoms/TextArea/TextArea.spec.js

@@ -0,0 +1,126 @@
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { TextArea } from './TextArea';
+import { jsx as _jsx } from "react/jsx-runtime";
+describe('TextArea', function () {
+  it('renders with placeholder and updates uncontrolled value on change', function () {
+    var onChange = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(TextArea, {
+      placeholder: "Escribe aqu\xED",
+      onChange: onChange,
+      rows: 3
+    }));
+    var textarea = screen.getByPlaceholderText('Escribe aquí');
+    fireEvent.change(textarea, {
+      target: {
+        value: 'hola'
+      }
+    });
+    expect(onChange).toHaveBeenCalled();
+    expect(textarea).toHaveValue('hola');
+  });
+  it('reflects controlled value updates', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(TextArea, {
+        value: "uno",
+        rows: 2,
+        onChange: jest.fn()
+      })),
+      rerender = _renderWithProviders.rerender;
+    expect(screen.getByRole('textbox')).toHaveValue('uno');
+    rerender(/*#__PURE__*/_jsx(TextArea, {
+      value: "dos",
+      rows: 2,
+      onChange: jest.fn()
+    }));
+    expect(screen.getByRole('textbox')).toHaveValue('dos');
+  });
+  it('forwards keyboard and focus callbacks', function () {
+    var onKeyDown = jest.fn();
+    var onFocus = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(TextArea, {
+      rows: 2,
+      onKeyDown: onKeyDown,
+      onFocus: onFocus
+    }));
+    var textarea = screen.getByRole('textbox');
+    fireEvent.keyDown(textarea, {
+      key: 'Enter'
+    });
+    fireEvent.focus(textarea);
+    expect(onKeyDown).toHaveBeenCalled();
+    expect(onFocus).toHaveBeenCalled();
+  });
+  it('calls onPaste and onBlur callbacks', function () {
+    var onPaste = jest.fn();
+    var onBlur = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(TextArea, {
+      rows: 2,
+      onPaste: onPaste,
+      onBlur: onBlur,
+      autoResizeOnPaste: false
+    }));
+    var textarea = screen.getByRole('textbox');
+    fireEvent.paste(textarea);
+    fireEvent.blur(textarea);
+    expect(onPaste).toHaveBeenCalled();
+    expect(onBlur).toHaveBeenCalled();
+  });
+  it('resizes on paste when autoResizeOnPaste is enabled', function () {
+    jest.useFakeTimers();
+    renderWithProviders(/*#__PURE__*/_jsx(TextArea, {
+      rows: 2,
+      defaultValue: "hola",
+      autoResizeOnPaste: true
+    }));
+    var textarea = screen.getByRole('textbox');
+    Object.defineProperty(textarea, 'scrollHeight', {
+      value: 120,
+      configurable: true
+    });
+    fireEvent.paste(textarea);
+    jest.advanceTimersByTime(10);
+    expect(textarea.style.height).toBe('120px');
+    jest.useRealTimers();
+  });
+  it('forces min height when the value is cleared', function () {
+    jest.useFakeTimers();
+    renderWithProviders(/*#__PURE__*/_jsx(TextArea, {
+      rows: 2,
+      defaultValue: "contenido largo",
+      minHeight: 60
+    }));
+    var textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, {
+      target: {
+        value: ''
+      }
+    });
+    jest.advanceTimersByTime(0);
+    expect(textarea.style.height).toBe('60px');
+    jest.useRealTimers();
+  });
+  it('supports defaultValue and click callbacks', function () {
+    var onClick = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(TextArea, {
+      rows: 2,
+      defaultValue: "inicial",
+      onClick: onClick,
+      autoResize: false
+    }));
+    var textarea = screen.getByRole('textbox');
+    expect(textarea).toHaveValue('inicial');
+    fireEvent.click(textarea);
+    expect(onClick).toHaveBeenCalled();
+  });
+  it('respects disabled and readOnly flags', function () {
+    renderWithProviders(/*#__PURE__*/_jsx(TextArea, {
+      rows: 2,
+      disabled: true,
+      readOnly: true,
+      value: "bloqueado",
+      onChange: jest.fn()
+    }));
+    expect(screen.getByRole('textbox')).toBeDisabled();
+    expect(screen.getByRole('textbox')).toHaveAttribute('readonly');
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fireEvent","renderWithProviders","screen","TextArea","jsx","_jsx","describe","it","onChange","jest","fn","placeholder","rows","textarea","getByPlaceholderText","change","target","value","expect","toHaveBeenCalled","toHaveValue","_renderWithProviders","rerender","getByRole","onKeyDown","onFocus","keyDown","key","focus","onPaste","onBlur","autoResizeOnPaste","paste","blur","useFakeTimers","defaultValue","Object","defineProperty","configurable","advanceTimersByTime","style","height","toBe","useRealTimers","minHeight","onClick","autoResize","click","disabled","readOnly","toBeDisabled","toHaveAttribute"],"sources":["../../../../src/components/atoms/TextArea/TextArea.spec.tsx"],"sourcesContent":["import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils'\nimport { TextArea } from './TextArea'\n\ndescribe('TextArea', () => {\n  it('renders with placeholder and updates uncontrolled value on change', () => {\n    const onChange = jest.fn()\n    renderWithProviders(<TextArea placeholder=\"Escribe aquí\" onChange={onChange} rows={3} />)\n\n    const textarea = screen.getByPlaceholderText('Escribe aquí')\n    fireEvent.change(textarea, { target: { value: 'hola' } })\n\n    expect(onChange).toHaveBeenCalled()\n    expect(textarea).toHaveValue('hola')\n  })\n\n  it('reflects controlled value updates', () => {\n    const { rerender } = renderWithProviders(<TextArea value=\"uno\" rows={2} onChange={jest.fn()} />)\n\n    expect(screen.getByRole('textbox')).toHaveValue('uno')\n\n    rerender(<TextArea value=\"dos\" rows={2} onChange={jest.fn()} />)\n\n    expect(screen.getByRole('textbox')).toHaveValue('dos')\n  })\n\n  it('forwards keyboard and focus callbacks', () => {\n    const onKeyDown = jest.fn()\n    const onFocus = jest.fn()\n    renderWithProviders(<TextArea rows={2} onKeyDown={onKeyDown} onFocus={onFocus} />)\n\n    const textarea = screen.getByRole('textbox')\n    fireEvent.keyDown(textarea, { key: 'Enter' })\n    fireEvent.focus(textarea)\n\n    expect(onKeyDown).toHaveBeenCalled()\n    expect(onFocus).toHaveBeenCalled()\n  })\n\n  it('calls onPaste and onBlur callbacks', () => {\n    const onPaste = jest.fn()\n    const onBlur = jest.fn()\n    renderWithProviders(<TextArea rows={2} onPaste={onPaste} onBlur={onBlur} autoResizeOnPaste={false} />)\n\n    const textarea = screen.getByRole('textbox')\n    fireEvent.paste(textarea)\n    fireEvent.blur(textarea)\n\n    expect(onPaste).toHaveBeenCalled()\n    expect(onBlur).toHaveBeenCalled()\n  })\n\n  it('resizes on paste when autoResizeOnPaste is enabled', () => {\n    jest.useFakeTimers()\n    renderWithProviders(<TextArea rows={2} defaultValue=\"hola\" autoResizeOnPaste />)\n\n    const textarea = screen.getByRole('textbox') as HTMLTextAreaElement\n    Object.defineProperty(textarea, 'scrollHeight', { value: 120, configurable: true })\n\n    fireEvent.paste(textarea)\n    jest.advanceTimersByTime(10)\n\n    expect(textarea.style.height).toBe('120px')\n    jest.useRealTimers()\n  })\n\n  it('forces min height when the value is cleared', () => {\n    jest.useFakeTimers()\n    renderWithProviders(<TextArea rows={2} defaultValue=\"contenido largo\" minHeight={60} />)\n\n    const textarea = screen.getByRole('textbox')\n    fireEvent.change(textarea, { target: { value: '' } })\n    jest.advanceTimersByTime(0)\n\n    expect(textarea.style.height).toBe('60px')\n    jest.useRealTimers()\n  })\n\n  it('supports defaultValue and click callbacks', () => {\n    const onClick = jest.fn()\n    renderWithProviders(<TextArea rows={2} defaultValue=\"inicial\" onClick={onClick} autoResize={false} />)\n\n    const textarea = screen.getByRole('textbox')\n    expect(textarea).toHaveValue('inicial')\n    fireEvent.click(textarea)\n    expect(onClick).toHaveBeenCalled()\n  })\n\n  it('respects disabled and readOnly flags', () => {\n    renderWithProviders(<TextArea rows={2} disabled readOnly value=\"bloqueado\" onChange={jest.fn()} />)\n\n    expect(screen.getByRole('textbox')).toBeDisabled()\n    expect(screen.getByRole('textbox')).toHaveAttribute('readonly')\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/components/atoms/ThirdButton.spec.js

@@ -0,0 +1,29 @@
+import { fireEvent, renderWithProviders, screen } from '../../test/test-utils';
+import { ThirdButton } from './ThirdButton';
+import { jsx as _jsx } from "react/jsx-runtime";
+describe('ThirdButton', function () {
+  it('forwards click events', function () {
+    var onClick = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(ThirdButton, {
+      onClick: onClick,
+      children: "Acci\xF3n"
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'Acción'
+    }));
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+  it('does not fire when disabled', function () {
+    var onClick = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(ThirdButton, {
+      disabled: true,
+      onClick: onClick,
+      children: "Acci\xF3n"
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: 'Acción'
+    }));
+    expect(onClick).not.toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/atoms/VideoModal/VideoModal.spec.js

@@ -0,0 +1,68 @@
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { VideoModal } from './VideoModal';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../../../hooks/useMaiaTaskPanelZIndex', function () {
+  return {
+    useMaiaTaskPanelZIndex: function useMaiaTaskPanelZIndex() {
+      return 1300;
+    }
+  };
+});
+jest.mock('../IconButton', function () {
+  return {
+    IconButton: function IconButton(_ref) {
+      var handleClick = _ref.handleClick,
+        tooltip = _ref.tooltip;
+      return /*#__PURE__*/_jsx("button", {
+        type: "button",
+        "aria-label": tooltip,
+        onClick: handleClick,
+        children: "close"
+      });
+    }
+  };
+});
+jest.mock('framer-motion', function () {
+  return {
+    AnimatePresence: function AnimatePresence(_ref2) {
+      var children = _ref2.children;
+      return children;
+    },
+    motion: {
+      div: function div(_ref3) {
+        var children = _ref3.children,
+          onClick = _ref3.onClick;
+        return /*#__PURE__*/_jsx("div", {
+          role: "presentation",
+          onClick: onClick,
+          children: children
+        });
+      }
+    }
+  };
+});
+describe('VideoModal', function () {
+  it('renders iframe and closes from overlay or button', function () {
+    var onClose = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(VideoModal, {
+      isOpen: true,
+      onClose: onClose,
+      videoUrl: "https://loom.test/embed"
+    }));
+    expect(screen.getByTitle('globals.helpVideo')).toHaveAttribute('src', 'https://loom.test/embed');
+    fireEvent.click(screen.getByRole('button', {
+      name: 'globals.close'
+    }));
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+  it('renders nothing when closed', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(VideoModal, {
+        isOpen: false,
+        onClose: jest.fn(),
+        videoUrl: "https://loom.test/embed"
+      })),
+      container = _renderWithProviders.container;
+    expect(container).toBeEmptyDOMElement();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmaXJlRXZlbnQiLCJyZW5kZXJXaXRoUHJvdmlkZXJzIiwic2NyZWVuIiwiVmlkZW9Nb2RhbCIsImpzeCIsIl9qc3giLCJqZXN0IiwibW9jayIsInVzZU1haWFUYXNrUGFuZWxaSW5kZXgiLCJJY29uQnV0dG9uIiwiX3JlZiIsImhhbmRsZUNsaWNrIiwidG9vbHRpcCIsInR5cGUiLCJvbkNsaWNrIiwiY2hpbGRyZW4iLCJBbmltYXRlUHJlc2VuY2UiLCJfcmVmMiIsIm1vdGlvbiIsImRpdiIsIl9yZWYzIiwicm9sZSIsImRlc2NyaWJlIiwiaXQiLCJvbkNsb3NlIiwiZm4iLCJpc09wZW4iLCJ2aWRlb1VybCIsImV4cGVjdCIsImdldEJ5VGl0bGUiLCJ0b0hhdmVBdHRyaWJ1dGUiLCJjbGljayIsImdldEJ5Um9sZSIsIm5hbWUiLCJ0b0hhdmVCZWVuQ2FsbGVkVGltZXMiLCJfcmVuZGVyV2l0aFByb3ZpZGVycyIsImNvbnRhaW5lciIsInRvQmVFbXB0eURPTUVsZW1lbnQiXSwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy9hdG9tcy9WaWRlb01vZGFsL1ZpZGVvTW9kYWwuc3BlYy50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBSZWFjdE5vZGUgfSBmcm9tICdyZWFjdCdcbmltcG9ydCB7IGZpcmVFdmVudCwgcmVuZGVyV2l0aFByb3ZpZGVycywgc2NyZWVuIH0gZnJvbSAnLi4vLi4vLi4vdGVzdC90ZXN0LXV0aWxzJ1xuaW1wb3J0IHsgVmlkZW9Nb2RhbCB9IGZyb20gJy4vVmlkZW9Nb2RhbCdcblxuamVzdC5tb2NrKCcuLi8uLi8uLi9ob29rcy91c2VNYWlhVGFza1BhbmVsWkluZGV4JywgKCkgPT4gKHtcbiAgdXNlTWFpYVRhc2tQYW5lbFpJbmRleDogKCkgPT4gMTMwMCxcbn0pKVxuXG5qZXN0Lm1vY2soJy4uL0ljb25CdXR0b24nLCAoKSA9PiAoe1xuICBJY29uQnV0dG9uOiAoeyBoYW5kbGVDbGljaywgdG9vbHRpcCB9OiB7IGhhbmRsZUNsaWNrPzogKCkgPT4gdm9pZDsgdG9vbHRpcDogc3RyaW5nIH0pID0+IChcbiAgICA8YnV0dG9uIHR5cGU9XCJidXR0b25cIiBhcmlhLWxhYmVsPXt0b29sdGlwfSBvbkNsaWNrPXtoYW5kbGVDbGlja30+XG4gICAgICBjbG9zZVxuICAgIDwvYnV0dG9uPlxuICApLFxufSkpXG5cbmplc3QubW9jaygnZnJhbWVyLW1vdGlvbicsICgpID0+ICh7XG4gIEFuaW1hdGVQcmVzZW5jZTogKHsgY2hpbGRyZW4gfTogeyBjaGlsZHJlbjogUmVhY3ROb2RlIH0pID0+IGNoaWxkcmVuLFxuICBtb3Rpb246IHtcbiAgICBkaXY6ICh7IGNoaWxkcmVuLCBvbkNsaWNrIH06IHsgY2hpbGRyZW46IFJlYWN0Tm9kZTsgb25DbGljaz86ICgpID0+IHZvaWQgfSkgPT4gKFxuICAgICAgPGRpdiByb2xlPVwicHJlc2VudGF0aW9uXCIgb25DbGljaz17b25DbGlja30+XG4gICAgICAgIHtjaGlsZHJlbn1cbiAgICAgIDwvZGl2PlxuICAgICksXG4gIH0sXG59KSlcblxuZGVzY3JpYmUoJ1ZpZGVvTW9kYWwnLCAoKSA9PiB7XG4gIGl0KCdyZW5kZXJzIGlmcmFtZSBhbmQgY2xvc2VzIGZyb20gb3ZlcmxheSBvciBidXR0b24nLCAoKSA9PiB7XG4gICAgY29uc3Qgb25DbG9zZSA9IGplc3QuZm4oKVxuICAgIHJlbmRlcldpdGhQcm92aWRlcnMoPFZpZGVvTW9kYWwgaXNPcGVuIG9uQ2xvc2U9e29uQ2xvc2V9IHZpZGVvVXJsPVwiaHR0cHM6Ly9sb29tLnRlc3QvZW1iZWRcIiAvPilcblxuICAgIGV4cGVjdChzY3JlZW4uZ2V0QnlUaXRsZSgnZ2xvYmFscy5oZWxwVmlkZW8nKSkudG9IYXZlQXR0cmlidXRlKCdzcmMnLCAnaHR0cHM6Ly9sb29tLnRlc3QvZW1iZWQnKVxuXG4gICAgZmlyZUV2ZW50LmNsaWNrKHNjcmVlbi5nZXRCeVJvbGUoJ2J1dHRvbicsIHsgbmFtZTogJ2dsb2JhbHMuY2xvc2UnIH0pKVxuICAgIGV4cGVjdChvbkNsb3NlKS50b0hhdmVCZWVuQ2FsbGVkVGltZXMoMSlcbiAgfSlcblxuICBpdCgncmVuZGVycyBub3RoaW5nIHdoZW4gY2xvc2VkJywgKCkgPT4ge1xuICAgIGNvbnN0IHsgY29udGFpbmVyIH0gPSByZW5kZXJXaXRoUHJvdmlkZXJzKFxuICAgICAgPFZpZGVvTW9kYWwgaXNPcGVuPXtmYWxzZX0gb25DbG9zZT17amVzdC5mbigpfSB2aWRlb1VybD1cImh0dHBzOi8vbG9vbS50ZXN0L2VtYmVkXCIgLz5cbiAgICApXG5cbiAgICBleHBlY3QoY29udGFpbmVyKS50b0JlRW1wdHlET01FbGVtZW50KClcbiAgfSlcbn0pXG4iXSwibWFwcGluZ3MiOiJBQUNBLFNBQVNBLFNBQVMsRUFBRUMsbUJBQW1CLEVBQUVDLE1BQU0sUUFBUSwwQkFBMEI7QUFDakYsU0FBU0MsVUFBVSxRQUFRLGNBQWM7QUFBQSxTQUFBQyxHQUFBLElBQUFDLElBQUE7QUFFekNDLElBQUksQ0FBQ0MsSUFBSSxDQUFDLHVDQUF1QyxFQUFFO0VBQUEsT0FBTztJQUN4REMsc0JBQXNCLEVBQUUsU0FBeEJBLHNCQUFzQkEsQ0FBQTtNQUFBLE9BQVEsSUFBSTtJQUFBO0VBQ3BDLENBQUM7QUFBQSxDQUFDLENBQUM7QUFFSEYsSUFBSSxDQUFDQyxJQUFJLENBQUMsZUFBZSxFQUFFO0VBQUEsT0FBTztJQUNoQ0UsVUFBVSxFQUFFLFNBQVpBLFVBQVVBLENBQUFDLElBQUE7TUFBQSxJQUFLQyxXQUFXLEdBQUFELElBQUEsQ0FBWEMsV0FBVztRQUFFQyxPQUFPLEdBQUFGLElBQUEsQ0FBUEUsT0FBTztNQUFBLG9CQUNqQ1AsSUFBQTtRQUFRUSxJQUFJLEVBQUMsUUFBUTtRQUFDLGNBQVlELE9BQVE7UUFBQ0UsT0FBTyxFQUFFSCxXQUFZO1FBQUFJLFFBQUEsRUFBQztNQUVqRSxDQUFRLENBQUM7SUFBQTtFQUViLENBQUM7QUFBQSxDQUFDLENBQUM7QUFFSFQsSUFBSSxDQUFDQyxJQUFJLENBQUMsZUFBZSxFQUFFO0VBQUEsT0FBTztJQUNoQ1MsZUFBZSxFQUFFLFNBQWpCQSxlQUFlQSxDQUFBQyxLQUFBO01BQUEsSUFBS0YsUUFBUSxHQUFBRSxLQUFBLENBQVJGLFFBQVE7TUFBQSxPQUFnQ0EsUUFBUTtJQUFBO0lBQ3BFRyxNQUFNLEVBQUU7TUFDTkMsR0FBRyxFQUFFLFNBQUxBLEdBQUdBLENBQUFDLEtBQUE7UUFBQSxJQUFLTCxRQUFRLEdBQUFLLEtBQUEsQ0FBUkwsUUFBUTtVQUFFRCxPQUFPLEdBQUFNLEtBQUEsQ0FBUE4sT0FBTztRQUFBLG9CQUN2QlQsSUFBQTtVQUFLZ0IsSUFBSSxFQUFDLGNBQWM7VUFBQ1AsT0FBTyxFQUFFQSxPQUFRO1VBQUFDLFFBQUEsRUFDdkNBO1FBQVEsQ0FDTixDQUFDO01BQUE7SUFFVjtFQUNGLENBQUM7QUFBQSxDQUFDLENBQUM7QUFFSE8sUUFBUSxDQUFDLFlBQVksRUFBRSxZQUFNO0VBQzNCQyxFQUFFLENBQUMsa0RBQWtELEVBQUUsWUFBTTtJQUMzRCxJQUFNQyxPQUFPLEdBQUdsQixJQUFJLENBQUNtQixFQUFFLENBQUMsQ0FBQztJQUN6QnhCLG1CQUFtQixjQUFDSSxJQUFBLENBQUNGLFVBQVU7TUFBQ3VCLE1BQU07TUFBQ0YsT0FBTyxFQUFFQSxPQUFRO01BQUNHLFFBQVEsRUFBQztJQUF5QixDQUFFLENBQUMsQ0FBQztJQUUvRkMsTUFBTSxDQUFDMUIsTUFBTSxDQUFDMkIsVUFBVSxDQUFDLG1CQUFtQixDQUFDLENBQUMsQ0FBQ0MsZUFBZSxDQUFDLEtBQUssRUFBRSx5QkFBeUIsQ0FBQztJQUVoRzlCLFNBQVMsQ0FBQytCLEtBQUssQ0FBQzdCLE1BQU0sQ0FBQzhCLFNBQVMsQ0FBQyxRQUFRLEVBQUU7TUFBRUMsSUFBSSxFQUFFO0lBQWdCLENBQUMsQ0FBQyxDQUFDO0lBQ3RFTCxNQUFNLENBQUNKLE9BQU8sQ0FBQyxDQUFDVSxxQkFBcUIsQ0FBQyxDQUFDLENBQUM7RUFDMUMsQ0FBQyxDQUFDO0VBRUZYLEVBQUUsQ0FBQyw2QkFBNkIsRUFBRSxZQUFNO0lBQ3RDLElBQUFZLG9CQUFBLEdBQXNCbEMsbUJBQW1CLGNBQ3ZDSSxJQUFBLENBQUNGLFVBQVU7UUFBQ3VCLE1BQU0sRUFBRSxLQUFNO1FBQUNGLE9BQU8sRUFBRWxCLElBQUksQ0FBQ21CLEVBQUUsQ0FBQyxDQUFFO1FBQUNFLFFBQVEsRUFBQztNQUF5QixDQUFFLENBQ3JGLENBQUM7TUFGT1MsU0FBUyxHQUFBRCxvQkFBQSxDQUFUQyxTQUFTO0lBSWpCUixNQUFNLENBQUNRLFNBQVMsQ0FBQyxDQUFDQyxtQkFBbUIsQ0FBQyxDQUFDO0VBQ3pDLENBQUMsQ0FBQztBQUNKLENBQUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==

package/lib/components/atoms/WithAppCfg.spec.js

@@ -0,0 +1,82 @@
+import { renderWithProviders, screen } from '../../test/test-utils';
+import { Features } from './WithFeatureValidation';
+import { withAppCfg } from './WithAppCfg';
+import { jsx as _jsx } from "react/jsx-runtime";
+jest.mock('../../lang', function () {
+  return {
+    __esModule: true,
+    "default": {}
+  };
+});
+jest.mock('../../services/apolloClient', function () {
+  return {
+    CORClient: {}
+  };
+});
+jest.mock('./WithFeatureValidation', function () {
+  return {
+    Features: {
+      PROJECT_SUMMARY: 'PROJECT_SUMMARY',
+      CHAT_AI: 'CHAT_AI'
+    },
+    WithFeatureValidation: function WithFeatureValidation(_ref) {
+      var children = _ref.children;
+      return children;
+    }
+  };
+});
+jest.mock('@apollo/client', function () {
+  return {
+    ApolloProvider: function ApolloProvider(_ref2) {
+      var children = _ref2.children;
+      return children;
+    }
+  };
+});
+jest.mock('react-i18next', function () {
+  return {
+    I18nextProvider: function I18nextProvider(_ref3) {
+      var children = _ref3.children;
+      return children;
+    }
+  };
+});
+var TestComponent = function TestComponent(_ref4) {
+  var label = _ref4.label;
+  return /*#__PURE__*/_jsx("span", {
+    children: label
+  });
+};
+describe('withAppCfg', function () {
+  it('wraps a component with providers and preserves props', function () {
+    var Wrapped = withAppCfg(TestComponent, Features.CHAT_AI);
+    renderWithProviders(/*#__PURE__*/_jsx(Wrapped, {
+      label: "wrapped-child"
+    }));
+    expect(screen.getByText('wrapped-child')).toBeInTheDocument();
+    expect(Wrapped.displayName).toBe('withAppCfg(TestComponent)');
+  });
+  it('prefers displayName over name when both are set', function () {
+    var Comp = function Comp(_ref5) {
+      var label = _ref5.label;
+      return /*#__PURE__*/_jsx("span", {
+        children: label
+      });
+    };
+    Comp.displayName = 'CustomDisplayName';
+    var Wrapped = withAppCfg(Comp, Features.CHAT_AI);
+    expect(Wrapped.displayName).toBe('withAppCfg(CustomDisplayName)');
+  });
+  it('falls back to Component when neither displayName nor name is available', function () {
+    var anon = function anon() {
+      return null;
+    };
+    Object.defineProperty(anon, 'name', {
+      value: ''
+    });
+    anon.displayName = '';
+    var Wrapped = withAppCfg(anon, Features.CHAT_AI);
+    expect(Wrapped.displayName).toBe('withAppCfg(Component)');
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/index.js

@@ -6,6 +6,7 @@ export { ProjectSummaryModal } from './molecules/ProjectSummaryModal';
 export { ContextMentionInput } from './molecules/ContextMentionInput';
 export { ProjectSummary } from './organisms/ProjectSummary';
 export { ChatAI } from './organisms/ChatAI';
+export { ChatAIPage } from './organisms/ChatAIPage';
 export { ProjectAIButton } from './organisms/ProjectAIButton';
 export { ClientAIButton } from './organisms/ClientAIButton';
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJNQUlBQnV0dG9uIiwiTWFpYVdyYXBwZXIiLCJNQUlBRXJyb3IiLCJBSUljb24iLCJQcm9qZWN0U3VtbWFyeU1vZGFsIiwiQ29udGV4dE1lbnRpb25JbnB1dCIsIlByb2plY3RTdW1tYXJ5IiwiQ2hhdEFJIiwiUHJvamVjdEFJQnV0dG9uIiwiQ2xpZW50QUlCdXR0b24iXSwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tcG9uZW50cy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBNQUlBQnV0dG9uIH0gZnJvbSAnLi9hdG9tcy9NQUlBQnV0dG9uJ1xuZXhwb3J0IHsgTWFpYVdyYXBwZXIgfSBmcm9tICcuL2F0b21zL01haWFXcmFwcGVyJ1xuZXhwb3J0IHsgTUFJQUVycm9yIH0gZnJvbSAnLi9hdG9tcy9NQUlBRXJyb3InXG5cbmV4cG9ydCB7IEFJSWNvbiB9IGZyb20gJy4vYXRvbXMvaWNvbnMnXG5cbmV4cG9ydCB7IFByb2plY3RTdW1tYXJ5TW9kYWwgfSBmcm9tICcuL21vbGVjdWxlcy9Qcm9qZWN0U3VtbWFyeU1vZGFsJ1xuZXhwb3J0IHsgQ29udGV4dE1lbnRpb25JbnB1dCB9IGZyb20gJy4vbW9sZWN1bGVzL0NvbnRleHRNZW50aW9uSW5wdXQnXG5cbmV4cG9ydCB7IFByb2plY3RTdW1tYXJ5IH0gZnJvbSAnLi9vcmdhbmlzbXMvUHJvamVjdFN1bW1hcnknXG5leHBvcnQgeyBDaGF0QUkgfSBmcm9tICcuL29yZ2FuaXNtcy9DaGF0QUknXG5leHBvcnQgeyBQcm9qZWN0QUlCdXR0b24gfSBmcm9tICcuL29yZ2FuaXNtcy9Qcm9qZWN0QUlCdXR0b24nXG5leHBvcnQgeyBDbGllbnRBSUJ1dHRvbiB9IGZyb20gJy4vb3JnYW5pc21zL0NsaWVudEFJQnV0dG9uJ1xuIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxVQUFVLFFBQVEsb0JBQW9CO0FBQy9DLFNBQVNDLFdBQVcsUUFBUSxxQkFBcUI7QUFDakQsU0FBU0MsU0FBUyxRQUFRLG1CQUFtQjtBQUU3QyxTQUFTQyxNQUFNLFFBQVEsZUFBZTtBQUV0QyxTQUFTQyxtQkFBbUIsUUFBUSxpQ0FBaUM7QUFDckUsU0FBU0MsbUJBQW1CLFFBQVEsaUNBQWlDO0FBRXJFLFNBQVNDLGNBQWMsUUFBUSw0QkFBNEI7QUFDM0QsU0FBU0MsTUFBTSxRQUFRLG9CQUFvQjtBQUMzQyxTQUFTQyxlQUFlLFFBQVEsNkJBQTZCO0FBQzdELFNBQVNDLGNBQWMsUUFBUSw0QkFBNEIiLCJpZ25vcmVMaXN0IjpbXX0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJNQUlBQnV0dG9uIiwiTWFpYVdyYXBwZXIiLCJNQUlBRXJyb3IiLCJBSUljb24iLCJQcm9qZWN0U3VtbWFyeU1vZGFsIiwiQ29udGV4dE1lbnRpb25JbnB1dCIsIlByb2plY3RTdW1tYXJ5IiwiQ2hhdEFJIiwiQ2hhdEFJUGFnZSIsIlByb2plY3RBSUJ1dHRvbiIsIkNsaWVudEFJQnV0dG9uIl0sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbXBvbmVudHMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgTUFJQUJ1dHRvbiB9IGZyb20gJy4vYXRvbXMvTUFJQUJ1dHRvbidcbmV4cG9ydCB7IE1haWFXcmFwcGVyIH0gZnJvbSAnLi9hdG9tcy9NYWlhV3JhcHBlcidcbmV4cG9ydCB7IE1BSUFFcnJvciB9IGZyb20gJy4vYXRvbXMvTUFJQUVycm9yJ1xuXG5leHBvcnQgeyBBSUljb24gfSBmcm9tICcuL2F0b21zL2ljb25zJ1xuXG5leHBvcnQgeyBQcm9qZWN0U3VtbWFyeU1vZGFsIH0gZnJvbSAnLi9tb2xlY3VsZXMvUHJvamVjdFN1bW1hcnlNb2RhbCdcbmV4cG9ydCB7IENvbnRleHRNZW50aW9uSW5wdXQgfSBmcm9tICcuL21vbGVjdWxlcy9Db250ZXh0TWVudGlvbklucHV0J1xuXG5leHBvcnQgeyBQcm9qZWN0U3VtbWFyeSB9IGZyb20gJy4vb3JnYW5pc21zL1Byb2plY3RTdW1tYXJ5J1xuZXhwb3J0IHsgQ2hhdEFJIH0gZnJvbSAnLi9vcmdhbmlzbXMvQ2hhdEFJJ1xuZXhwb3J0IHsgQ2hhdEFJUGFnZSB9IGZyb20gJy4vb3JnYW5pc21zL0NoYXRBSVBhZ2UnXG5leHBvcnQgeyBQcm9qZWN0QUlCdXR0b24gfSBmcm9tICcuL29yZ2FuaXNtcy9Qcm9qZWN0QUlCdXR0b24nXG5leHBvcnQgeyBDbGllbnRBSUJ1dHRvbiB9IGZyb20gJy4vb3JnYW5pc21zL0NsaWVudEFJQnV0dG9uJ1xuIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxVQUFVLFFBQVEsb0JBQW9CO0FBQy9DLFNBQVNDLFdBQVcsUUFBUSxxQkFBcUI7QUFDakQsU0FBU0MsU0FBUyxRQUFRLG1CQUFtQjtBQUU3QyxTQUFTQyxNQUFNLFFBQVEsZUFBZTtBQUV0QyxTQUFTQyxtQkFBbUIsUUFBUSxpQ0FBaUM7QUFDckUsU0FBU0MsbUJBQW1CLFFBQVEsaUNBQWlDO0FBRXJFLFNBQVNDLGNBQWMsUUFBUSw0QkFBNEI7QUFDM0QsU0FBU0MsTUFBTSxRQUFRLG9CQUFvQjtBQUMzQyxTQUFTQyxVQUFVLFFBQVEsd0JBQXdCO0FBQ25ELFNBQVNDLGVBQWUsUUFBUSw2QkFBNkI7QUFDN0QsU0FBU0MsY0FBYyxRQUFRLDRCQUE0QiIsImlnbm9yZUxpc3QiOltdfQ==