@eeacms/volto-cca-policy 1.0.25 → 1.0.26

package/src/components/Search/NavigatorGuide/NavigatorGuideContentView.test.jsx

@@ -1,6 +1,6 @@
 import React from 'react';
 import '@testing-library/jest-dom';
-import { fireEvent, render } from '@testing-library/react';
+import { fireEvent, render, screen } from '@testing-library/react';
 import { IntlProvider } from 'react-intl';
 import { useAtom } from 'jotai';
 import { useSelector } from 'react-redux';
@@ -21,13 +21,14 @@ jest.mock('./useGuideFacetOptions', () => ({
   default: jest.fn(),
 }));
 
-const renderGuide = (result) => {
+const renderGuide = (result, searchContext = {}) => {
   useSearchContext.mockReturnValue({
     filters: [{ field: 'cca_adaptation_sectors.keyword', values: ['Water'] }],
     facets: {},
     results: [result],
     totalResults: 1,
     isLoading: false,
+    ...searchContext,
   });
   return render(
     <IntlProvider locale="en">
@@ -92,3 +93,108 @@ describe('NavigatorGuideContentView thumbnails', () => {
     expect(thumbnail.querySelector('.ri-stack-line')).toBeInTheDocument();
   });
 });
+
+describe('NavigatorGuideContentView adaptation steps', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useAtom.mockReturnValue([2, jest.fn()]);
+    useSelector.mockReturnValue('en');
+    useHistory.mockReturnValue({ push: jest.fn() });
+    useGuideFacetOptions.mockReturnValue({
+      'cca_adaptation_support_cycle_step.keyword': [
+        'Step 2: Assess',
+        'Step 1: Prepare',
+      ],
+    });
+  });
+
+  it('orders steps and requires every selected step', () => {
+    const addFilter = jest.fn();
+    renderGuide(
+      { title: 'Guide tool', href: '/tools/guide-tool' },
+      {
+        filters: [],
+        addFilter,
+        facets: {
+          'cca_adaptation_support_cycle_step.keyword': [
+            {
+              data: [
+                { value: 'Step 2: Assess', count: 9 },
+                { value: 'Step 1: Prepare', count: 1 },
+              ],
+            },
+          ],
+        },
+      },
+    );
+
+    const labels = screen.getAllByText(/^Step [12]:/);
+    expect(labels.map((label) => label.textContent)).toEqual([
+      'Step 1: Prepare',
+      'Step 2: Assess',
+    ]);
+    fireEvent.click(screen.getByText('Step 2: Assess'));
+    expect(addFilter).toHaveBeenCalledWith(
+      'cca_adaptation_support_cycle_step.keyword',
+      'Step 2: Assess',
+      'all',
+    );
+  });
+
+  it('does not show an unrelated selected step on a preview tool', () => {
+    const { container } = renderGuide(
+      {
+        title: 'Guide tool',
+        href: '/tools/guide-tool',
+        cca_adaptation_support_cycle_step: { raw: ['Step 1: Prepare'] },
+      },
+      {
+        filters: [
+          {
+            field: 'cca_adaptation_support_cycle_step.keyword',
+            values: ['Step 1: Prepare', 'Step 2: Assess'],
+            type: 'all',
+          },
+        ],
+      },
+    );
+
+    expect(
+      container.querySelectorAll(
+        '.navigator-guide-preview-tags .navigator-tag',
+      ),
+    ).toHaveLength(1);
+    expect(
+      container.querySelector('.navigator-guide-preview-tags'),
+    ).toHaveTextContent('Step 1');
+  });
+});
+
+describe('NavigatorGuideContentView climate hazards', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useAtom.mockReturnValue([1, jest.fn()]);
+    useSelector.mockReturnValue('en');
+    useHistory.mockReturnValue({ push: jest.fn() });
+    useGuideFacetOptions.mockReturnValue({});
+  });
+
+  it('uses the hazard tag style for a selected climate hazard', () => {
+    const { container } = renderGuide(
+      {
+        title: 'Guide tool',
+        href: '/tools/guide-tool',
+        cca_climate_impacts: { raw: ['Flooding'] },
+      },
+      {
+        filters: [
+          { field: 'cca_climate_impacts.keyword', values: ['Flooding'] },
+        ],
+      },
+    );
+
+    expect(
+      container.querySelector('.navigator-guide-preview-tags .hazard'),
+    ).toHaveTextContent('Flooding');
+  });
+});

package/src/components/Search/NavigatorGuide/utils.js

@@ -28,3 +28,18 @@ export const mergeGuideOptions = (
       !selectedValues.includes(option.value),
   }));
 };
+
+export const sortAdaptationSteps = (options) =>
+  [...options].sort((a, b) => {
+    const aStep = /^Step\s+(\d+)\b/i.exec(a.value);
+    const bStep = /^Step\s+(\d+)\b/i.exec(b.value);
+
+    if (aStep && bStep) {
+      return (
+        Number(aStep[1]) - Number(bStep[1]) || a.value.localeCompare(b.value)
+      );
+    }
+    if (aStep) return -1;
+    if (bStep) return 1;
+    return a.value.localeCompare(b.value);
+  });

package/src/components/Search/NavigatorGuide/utils.test.js

@@ -1,4 +1,4 @@
-import { mergeGuideOptions } from './utils';
+import { mergeGuideOptions, sortAdaptationSteps } from './utils';
 
 describe('Navigator Guide utilities', () => {
   it('keeps unavailable values and marks them as disabled', () => {
@@ -37,4 +37,21 @@ describe('Navigator Guide utilities', () => {
       { value: 'Energy', count: 3, disabled: false },
     ]);
   });
+
+  it('keeps adaptation steps in numeric order regardless of match counts', () => {
+    const options = [
+      { value: 'Step 10: Review', count: 9 },
+      { value: 'Step 3: Plan', count: 20 },
+      { value: 'Step 1: Prepare', count: 1 },
+      { value: 'Step 2: Assess', count: 5 },
+    ];
+
+    expect(sortAdaptationSteps(options).map(({ value }) => value)).toEqual([
+      'Step 1: Prepare',
+      'Step 2: Assess',
+      'Step 3: Plan',
+      'Step 10: Review',
+    ]);
+    expect(options[0].value).toBe('Step 10: Review');
+  });
 });

package/src/components/index.js

@@ -1,5 +1,7 @@
 export { default as BannerTitle } from './theme/BannerTitle/BannerTitle';
 export { default as PortalMessage } from './theme/PortalMessage/PortalMessage';
+export { default as TagOverflowPopup } from './theme/TagOverflowPopup';
+export { default as ToolThumbnail } from './theme/ToolThumbnail/ToolThumbnail';
 export { default as TranslationDisclaimer } from './theme/TranslationDisclaimer/TranslationDisclaimer';
 export { default as ASTNavigation } from './theme/ASTNavigation/ASTNavigation';
 export { default as RedirectToLogin } from './theme/RedirectToLogin/RedirectToLogin';

package/src/components/manage/Blocks/ChatbotCatalogue/astUtils.js

@@ -136,12 +136,20 @@ export function parseMarkdownLines(content) {
       continue;
     }
 
-    // List item: 1. Item or * Item or - Item
-    const listMatch = trimmed.match(/^(\d+\.|[*+-])\s+(.*)$/);
+    // List item: 1. Item or * Item or - Item or [2] Item
+    const listMatch = trimmed.match(/^(\d+\.|[*+-]|\[\d+\])\s+(.*)$/);
     if (listMatch) {
       flushParagraph();
       const isOrdered = /^\d+\./.test(listMatch[1]);
-      const itemText = listMatch[2].trim();
+      let itemText = listMatch[2].trim();
+
+      // Clean stray leading asterisks if odd number of asterisks
+      if (itemText.startsWith('**')) {
+        const count = (itemText.match(/\*\*/g) || []).length;
+        if (count % 2 === 1) {
+          itemText = itemText.replace(/^\*\*\s*/, '');
+        }
+      }
 
       const listItemNode = {
         type: 'listItem',
@@ -247,3 +255,121 @@ export function unwrapCardLists(children) {
     }
   }
 }
+
+/**
+ * Recursively cleans stray unclosed leading asterisks (`**`) from paragraphs
+ * and list items. CommonMark leaves unmatched asterisks as literal text in
+ * the first text node when the closing asterisks cannot be paired.
+ */
+export function cleanStrayLeadingAsterisks(node) {
+  if (!node) return;
+  if (node.type === 'paragraph' || node.type === 'listItem') {
+    if (Array.isArray(node.children)) {
+      const firstChild = node.children[0];
+      if (
+        firstChild?.type === 'text' &&
+        typeof firstChild.value === 'string' &&
+        /^\s*\*\*([^*]|$)/.test(firstChild.value)
+      ) {
+        firstChild.value = firstChild.value.replace(/^\s*\*\*\s*/, '');
+      }
+    }
+  }
+  if (Array.isArray(node.children)) {
+    node.children.forEach(cleanStrayLeadingAsterisks);
+  }
+}
+
+/**
+ * Checks if a string starts with a citation reference marker like `[2] Title`
+ */
+export function isCitationText(text) {
+  return typeof text === 'string' && /^\[\d+\]\s+/.test(text.trimStart());
+}
+
+/**
+ * Normalizes citation paragraphs following a list into list items so that
+ * reference lists like `[2] ... \n [3] ...` do not break out of an unordered
+ * or ordered list (such as under `### Limitations`). Also converts standalone
+ * citation paragraphs into lists.
+ */
+export function normalizeCitationParagraphsToLists(children) {
+  if (!Array.isArray(children)) return;
+
+  for (let i = 0; i < children.length; i += 1) {
+    const curr = children[i];
+
+    // Case 1: Existing list followed by citation paragraph(s)
+    if (curr.type === 'list' && Array.isArray(curr.children)) {
+      while (i + 1 < children.length) {
+        const next = children[i + 1];
+        if (!next || next.type !== 'paragraph') break;
+        const fullText = getNodeText(next).trim();
+        if (!isCitationText(fullText)) break;
+
+        // If single text node with multiple newline-separated lines
+        if (
+          Array.isArray(next.children) &&
+          next.children.length === 1 &&
+          next.children[0].type === 'text'
+        ) {
+          const lines = next.children[0].value
+            .split(/\r?\n/)
+            .filter((l) => l.trim());
+          if (lines.every(isCitationText)) {
+            lines.forEach((line) => {
+              curr.children.push({
+                type: 'listItem',
+                children: [
+                  {
+                    type: 'paragraph',
+                    children: [{ type: 'text', value: line.trim() }],
+                  },
+                ],
+              });
+            });
+            children.splice(i + 1, 1);
+            continue;
+          }
+        }
+
+        curr.children.push({
+          type: 'listItem',
+          children: [next],
+        });
+        children.splice(i + 1, 1);
+      }
+    } else if (curr.type === 'paragraph') {
+      // Case 2: Standalone citation paragraph not preceded by a list
+      const fullText = getNodeText(curr).trim();
+      if (isCitationText(fullText)) {
+        if (
+          Array.isArray(curr.children) &&
+          curr.children.length === 1 &&
+          curr.children[0].type === 'text'
+        ) {
+          const lines = curr.children[0].value
+            .split(/\r?\n/)
+            .filter((l) => l.trim());
+          if (lines.every(isCitationText)) {
+            const listItems = lines.map((line) => ({
+              type: 'listItem',
+              children: [
+                {
+                  type: 'paragraph',
+                  children: [{ type: 'text', value: line.trim() }],
+                },
+              ],
+            }));
+            children.splice(i, 1, {
+              type: 'list',
+              ordered: false,
+              children: listItems,
+            });
+            i += listItems.length - 1;
+          }
+        }
+      }
+    }
+  }
+}

package/src/components/manage/Blocks/ChatbotCatalogue/astUtils.test.js

@@ -1,7 +1,10 @@
 import {
   DOC_MARKER_RE,
+  cleanStrayLeadingAsterisks,
   deduplicateAdjacentHeadings,
+  isCitationText,
   isNextStepsHeading,
+  normalizeCitationParagraphsToLists,
   parseMarkdownLines,
   shouldUnwrapCodeNode,
   unwrapCardLists,
@@ -205,3 +208,207 @@ describe('unwrapCardLists', () => {
     expect(children[1].value).toBe('Tool 2');
   });
 });
+
+describe('cleanStrayLeadingAsterisks', () => {
+  it('strips unmatched leading ** from paragraphs and list items preceding strong elements', () => {
+    const node = {
+      type: 'listItem',
+      children: [
+        {
+          type: 'paragraph',
+          children: [
+            {
+              type: 'text',
+              value: '**Run a rapid, multi-hazard screening with the ',
+            },
+            {
+              type: 'strong',
+              children: [
+                {
+                  type: 'text',
+                  value: 'Pathways2Resilience Climate Toolbox',
+                },
+              ],
+            },
+            {
+              type: 'text',
+              value: ' to identify climate threats.',
+            },
+          ],
+        },
+      ],
+    };
+
+    cleanStrayLeadingAsterisks(node);
+    const textNode = node.children[0].children[0];
+    expect(textNode.value).toBe(
+      'Run a rapid, multi-hazard screening with the ',
+    );
+  });
+
+  it('leaves paragraphs without leading ** untouched', () => {
+    const node = {
+      type: 'paragraph',
+      children: [
+        {
+          type: 'text',
+          value: 'Normal text without asterisks',
+        },
+      ],
+    };
+
+    cleanStrayLeadingAsterisks(node);
+    expect(node.children[0].value).toBe('Normal text without asterisks');
+  });
+});
+
+describe('isCitationText', () => {
+  it('identifies citation markers', () => {
+    expect(isCitationText('[2] Pathways2Resilience Climate Toolbox')).toBe(
+      true,
+    );
+    expect(isCitationText('  [15] Multi-digit citation')).toBe(true);
+    expect(isCitationText('Normal paragraph text')).toBe(false);
+    expect(isCitationText('1. Numbered list item')).toBe(false);
+    expect(isCitationText(null)).toBe(false);
+  });
+});
+
+describe('normalizeCitationParagraphsToLists', () => {
+  it('appends newline-separated citation lines following a list as list items', () => {
+    const children = [
+      {
+        type: 'list',
+        ordered: false,
+        children: [
+          {
+            type: 'listItem',
+            children: [
+              {
+                type: 'paragraph',
+                children: [
+                  {
+                    type: 'text',
+                    value: 'The Greek Climate Change Adaptation Hub limitation',
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+      {
+        type: 'paragraph',
+        children: [
+          {
+            type: 'text',
+            value:
+              '[2] Pathways2Resilience meta-tool\n[3] NATURE DEMO DST analysis\n[4] Greek Hub resilience audit',
+          },
+        ],
+      },
+    ];
+
+    normalizeCitationParagraphsToLists(children);
+    // Paragraph should be merged into list
+    expect(children).toHaveLength(1);
+    const list = children[0];
+    expect(list.type).toBe('list');
+    expect(list.children).toHaveLength(4);
+    expect(list.children[0].children[0].children[0].value).toBe(
+      'The Greek Climate Change Adaptation Hub limitation',
+    );
+    expect(list.children[1].children[0].children[0].value).toBe(
+      '[2] Pathways2Resilience meta-tool',
+    );
+    expect(list.children[2].children[0].children[0].value).toBe(
+      '[3] NATURE DEMO DST analysis',
+    );
+    expect(list.children[3].children[0].children[0].value).toBe(
+      '[4] Greek Hub resilience audit',
+    );
+  });
+
+  it('appends consecutive citation paragraphs to a preceding list', () => {
+    const children = [
+      {
+        type: 'list',
+        ordered: false,
+        children: [
+          {
+            type: 'listItem',
+            children: [
+              {
+                type: 'paragraph',
+                children: [{ type: 'text', value: 'Initial bullet' }],
+              },
+            ],
+          },
+        ],
+      },
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: '[2] Second item' }],
+      },
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: '[3] Third item' }],
+      },
+    ];
+
+    normalizeCitationParagraphsToLists(children);
+    expect(children).toHaveLength(1);
+    expect(children[0].children).toHaveLength(3);
+  });
+
+  it('converts standalone citation paragraphs into a list', () => {
+    const children = [
+      {
+        type: 'paragraph',
+        children: [
+          {
+            type: 'text',
+            value: '[2] Item A\n[3] Item B',
+          },
+        ],
+      },
+    ];
+
+    normalizeCitationParagraphsToLists(children);
+    expect(children).toHaveLength(1);
+    expect(children[0].type).toBe('list');
+    expect(children[0].children).toHaveLength(2);
+  });
+
+  it('leaves non-citation paragraphs untouched', () => {
+    const children = [
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: 'Regular paragraph' }],
+      },
+    ];
+
+    normalizeCitationParagraphsToLists(children);
+    expect(children).toHaveLength(1);
+    expect(children[0].type).toBe('paragraph');
+  });
+});
+
+describe('parseMarkdownLines enhancements', () => {
+  it('parses [2] marker lines as list items and cleans stray leading asterisks', () => {
+    const markdown =
+      '1. **Run a screening with the **Pathways2Resilience Toolbox** for risks\n[2] Citation line description';
+    const nodes = parseMarkdownLines(markdown);
+    expect(nodes).toHaveLength(2);
+    expect(nodes[0].type).toBe('list');
+    expect(nodes[0].ordered).toBe(true);
+    // Unmatched leading ** was cleaned, leaving the properly matched **Toolbox**
+    expect(nodes[0].children[0].children[0].children[0].value).toBe(
+      'Run a screening with the **Pathways2Resilience Toolbox** for risks',
+    );
+    expect(nodes[1].type).toBe('list');
+    expect(nodes[1].children[0].children[0].children[0].value).toBe(
+      'Citation line description',
+    );
+  });
+});

package/src/components/manage/Blocks/ChatbotCatalogue/docCards.js

@@ -19,7 +19,9 @@
 
 import {
   DOC_MARKER_RE,
+  cleanStrayLeadingAsterisks,
   deduplicateAdjacentHeadings,
+  normalizeCitationParagraphsToLists,
   parseMarkdownLines,
   shouldUnwrapCodeNode,
   unwrapCardLists,
@@ -132,6 +134,12 @@ export const remarkCcaDocCards = function () {
     // 5. Unwrap paragraphs that only contain ccaDocCard nodes
     unwrapCardParagraphs(tree.children);
 
+    // 6. Normalize citation paragraphs following lists into list items
+    normalizeCitationParagraphsToLists(tree.children);
+
+    // 7. Clean stray unclosed leading asterisks in list items and paragraphs
+    cleanStrayLeadingAsterisks(tree);
+
     return tree;
   };
 };

package/src/components/manage/Blocks/ChatbotCatalogue/docCards.test.js

@@ -249,4 +249,76 @@ describe('remarkCcaDocCards', () => {
     expect(result.children[1].type).toBe('ccaDocCard');
     expect(result.children[1].value).toBe('Tool B');
   });
+
+  it('normalizes citation paragraphs following a list so they become list items', () => {
+    const tree = {
+      type: 'root',
+      children: [
+        {
+          type: 'list',
+          ordered: false,
+          children: [
+            {
+              type: 'listItem',
+              children: [
+                {
+                  type: 'paragraph',
+                  children: [
+                    { type: 'text', value: 'National context limitation' },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+        {
+          type: 'paragraph',
+          children: [
+            {
+              type: 'text',
+              value:
+                '[2] Pathways2Resilience Toolbox\n[3] NATURE DEMO DST analysis',
+            },
+          ],
+        },
+      ],
+    };
+
+    const result = applyPlugin(tree);
+    expect(result.children).toHaveLength(1);
+    expect(result.children[0].type).toBe('list');
+    expect(result.children[0].children).toHaveLength(3);
+    expect(result.children[0].children[1].children[0].children[0].value).toBe(
+      '[2] Pathways2Resilience Toolbox',
+    );
+    expect(result.children[0].children[2].children[0].children[0].value).toBe(
+      '[3] NATURE DEMO DST analysis',
+    );
+  });
+
+  it('cleans stray leading asterisks in list items and paragraphs', () => {
+    const tree = {
+      type: 'root',
+      children: [
+        {
+          type: 'paragraph',
+          children: [
+            {
+              type: 'text',
+              value: '**Run a rapid screening with the ',
+            },
+            {
+              type: 'strong',
+              children: [{ type: 'text', value: 'Tool A' }],
+            },
+          ],
+        },
+      ],
+    };
+
+    const result = applyPlugin(tree);
+    expect(result.children[0].children[0].value).toBe(
+      'Run a rapid screening with the ',
+    );
+  });
 });

package/src/components/manage/Blocks/ChatbotCatalogue/nextSteps.js

@@ -10,6 +10,7 @@
 
 import {
   NEXT_STEPS_HEADING_RE,
+  cleanStrayLeadingAsterisks,
   getNodeText,
   isNextStepsHeading,
   parseMarkdownLines,
@@ -61,6 +62,9 @@ function transformContainer(children) {
         children: collected,
       };
 
+      // Clean unclosed leading asterisks on list items inside container
+      cleanStrayLeadingAsterisks(containerNode);
+
       // Replace heading and all collected siblings with the container node
       children.splice(i, 1 + (j - (i + 1)), containerNode);
     } else if (