@net7/boilerplate-arianna 4.9.7 → 5.0.0

package/esm2022/lib/data-sources/extended-tree.ds.mjs

@@ -0,0 +1,157 @@
+import { DataSource } from '@net7/core';
+import { helpers } from '@net7/boilerplate-common';
+import nodeHelper from '../helpers/node.helper';
+const PAGE_LIMIT = 5;
+const SEARCH_OPEN_CLASS = 'search-is-open';
+export class AwExtendedTreeDS extends DataSource {
+    constructor() {
+        super(...arguments);
+        this.searchIsOpen = false;
+        this.transform = ({ parent, nodes }) => {
+            const { totalCount } = nodes;
+            const { title, params, basePath, lite, configKeys, fallback, } = this.options;
+            const page = params.page ? +params.page : 1;
+            const limit = params.limit ? +params.limit : 10;
+            this.searchIsOpen = (this.searchIsOpen
+                || (typeof params.query === 'string' && params.query.trim()));
+            // header
+            const header = {
+                title: {
+                    main: {
+                        text: `${title} <span class="aw-extended-tree__total">(${totalCount})</span>`,
+                    },
+                    secondary: {
+                        text: `In: "${parent.label}"`
+                    }
+                },
+                actions: {
+                    search: {
+                        placeholder: 'Cerca negli oggetti culturali',
+                        payload: 'search-input',
+                        button: {
+                            text: '',
+                            payload: 'search-button'
+                        }
+                    },
+                },
+                classes: this.searchIsOpen ? SEARCH_OPEN_CLASS : ''
+            };
+            // items
+            const items = (nodes.items || []).map((item) => ({
+                icon: nodeHelper.getNodeIcon(configKeys, item),
+                thumbnail: lite ? null : item.img,
+                label: item.label,
+                anchor: {
+                    href: `${basePath}/${item.id}/${helpers.slugify(item.label)}`
+                }
+            }));
+            // pagination
+            const pagination = this.getPagination(page, totalCount, limit);
+            // page input
+            const pageInput = {
+                id: 'page-input',
+                type: 'number',
+                // value: page,
+                placeholder: 'pag',
+                inputPayload: 'page-input-change',
+                enterPayload: 'page-input-enter',
+            };
+            // results limit select
+            const limitSelect = {
+                id: 'limit-select',
+                label: 'Numero di risultati',
+                options: [10, 25, 50].map((size) => ({
+                    label: `${size}`,
+                    value: size,
+                    selected: size === limit
+                })),
+                payload: 'limit-select',
+            };
+            return {
+                header,
+                items,
+                pagination,
+                pageInput,
+                limitSelect,
+                fallback: nodes ? fallback : null,
+                loading: false,
+            };
+        };
+    }
+    setLoading(loading) {
+        this.output.loading = loading;
+    }
+    toggleSearch() {
+        this.searchIsOpen = !this.searchIsOpen;
+        const { header } = this.output;
+        header.classes = this.searchIsOpen ? SEARCH_OPEN_CLASS : '';
+        // trigger focus
+        if (this.searchIsOpen) {
+            setTimeout(() => {
+                const inputEl = document.querySelector('.aw-extended-tree input.n7-inner-title__search-bar');
+                inputEl.focus();
+            }, 500);
+        }
+    }
+    getPagination(page, totalCount, limit) {
+        const pages = Math.ceil(totalCount / limit);
+        return {
+            links: this.getPaginationLinks(page, pages),
+            first: {
+                anchor: {
+                    payload: 1,
+                },
+                classes: page === 1 ? 'is-disabled' : '',
+            },
+            prev: {
+                anchor: {
+                    payload: page === 1 ? 1 : page - 1,
+                },
+                classes: page === 1 ? 'is-disabled' : ''
+            },
+            next: {
+                anchor: {
+                    payload: page === pages ? pages : page + 1,
+                },
+                classes: page === pages ? 'is-disabled' : '',
+            },
+            last: {
+                anchor: {
+                    payload: pages,
+                },
+                classes: page === pages ? 'is-disabled' : '',
+            }
+        };
+    }
+    getPaginationLinks(page, pages) {
+        let firstItem = 1;
+        const links = [];
+        const limit = PAGE_LIMIT;
+        let last = limit;
+        if (pages > limit) {
+            const steps = Math.floor(limit / 2);
+            if (page > steps) {
+                firstItem = page - steps;
+            }
+            if ((page + steps) > pages) {
+                firstItem = (pages - limit) + 1;
+            }
+        }
+        else {
+            last = pages;
+        }
+        let i;
+        for (i = 0; i < last; i += 1) {
+            const itemPage = firstItem + i;
+            links.push({
+                text: itemPage,
+                classes: itemPage === page ? 'is-disabled' : '',
+                anchor: {
+                    payload: itemPage,
+                }
+            });
+        }
+        return links;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extended-tree.ds.js","sourceRoot":"","sources":["../../../../../projects/n7-boilerplate-arianna/src/lib/data-sources/extended-tree.ds.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Button, InnerTitleData, InputSelectData, InputTextData, PaginationData\n} from '@net7/components';\nimport { DataSource } from '@net7/core';\nimport { helpers } from '@net7/boilerplate-common';\nimport { ExtendedTreeData } from '../components/extended-tree/extended-tree';\nimport nodeHelper from '../helpers/node.helper';\n\ntype ParentResponse = {\n  label: string;\n}\n\nexport type NodesResponse = {\n  items: {\n    img?: string;\n    label: string;\n    id: string;\n    document_type: string;\n    document_classification: string;\n    breadcrumbs?: {\n      label: string;\n      link: string;\n    }[];\n  }[];\n  totalCount: number;\n}\n\nconst PAGE_LIMIT = 5;\n\nconst SEARCH_OPEN_CLASS = 'search-is-open';\n\nexport class AwExtendedTreeDS extends DataSource {\n  public searchIsOpen = false;\n\n  protected transform = (\n    { parent, nodes }:\n    { parent: ParentResponse; nodes: NodesResponse }\n  ): ExtendedTreeData => {\n    const { totalCount } = nodes;\n    const {\n      title,\n      params,\n      basePath,\n      lite,\n      configKeys,\n      fallback,\n    } = this.options;\n    const page = params.page ? +params.page : 1;\n    const limit = params.limit ? +params.limit : 10;\n    this.searchIsOpen = (\n      this.searchIsOpen\n      || (typeof params.query === 'string' && params.query.trim())\n    );\n    // header\n    const header: InnerTitleData = {\n      title: {\n        main: {\n          text: `${title} <span class=\"aw-extended-tree__total\">(${totalCount})</span>`,\n        },\n        secondary: {\n          text: `In: \"${parent.label}\"`\n        }\n      },\n      actions: {\n        search: {\n          placeholder: 'Cerca negli oggetti culturali',\n          payload: 'search-input',\n          button: {\n            text: '',\n            payload: 'search-button'\n          }\n        },\n      },\n      classes: this.searchIsOpen ? SEARCH_OPEN_CLASS : ''\n    };\n    // items\n    const items = (nodes.items || []).map((item) => ({\n      icon: nodeHelper.getNodeIcon(configKeys, item),\n      thumbnail: lite ? null : item.img,\n      label: item.label,\n      anchor: {\n        href: `${basePath}/${item.id}/${helpers.slugify(item.label)}`\n      }\n    }));\n    // pagination\n    const pagination: PaginationData = this.getPagination(page, totalCount, limit);\n    // page input\n    const pageInput: InputTextData = {\n      id: 'page-input',\n      type: 'number',\n      // value: page,\n      placeholder: 'pag',\n      inputPayload: 'page-input-change',\n      enterPayload: 'page-input-enter',\n    };\n    // results limit select\n    const limitSelect: InputSelectData = {\n      id: 'limit-select',\n      label: 'Numero di risultati',\n      options: [10, 25, 50].map((size) => ({\n        label: `${size}`,\n        value: size,\n        selected: size === limit\n      })),\n      payload: 'limit-select',\n    };\n    return {\n      header,\n      items,\n      pagination,\n      pageInput,\n      limitSelect,\n      fallback: nodes ? fallback : null,\n      loading: false,\n    };\n  };\n\n  public setLoading(loading: boolean) {\n    this.output.loading = loading;\n  }\n\n  public toggleSearch() {\n    this.searchIsOpen = !this.searchIsOpen;\n\n    const { header } = this.output;\n    header.classes = this.searchIsOpen ? SEARCH_OPEN_CLASS : '';\n\n    // trigger focus\n    if (this.searchIsOpen) {\n      setTimeout(() => {\n        const inputEl: HTMLInputElement = document.querySelector('.aw-extended-tree input.n7-inner-title__search-bar');\n        inputEl.focus();\n      }, 500);\n    }\n  }\n\n  private getPagination(page, totalCount, limit): PaginationData {\n    const pages = Math.ceil(totalCount / limit);\n\n    return {\n      links: this.getPaginationLinks(page, pages),\n      first: {\n        anchor: {\n          payload: 1,\n        },\n        classes: page === 1 ? 'is-disabled' : '',\n      },\n      prev: {\n        anchor: {\n          payload: page === 1 ? 1 : page - 1,\n        },\n        classes: page === 1 ? 'is-disabled' : ''\n      },\n      next: {\n        anchor: {\n          payload: page === pages ? pages : page + 1,\n        },\n        classes: page === pages ? 'is-disabled' : '',\n      },\n      last: {\n        anchor: {\n          payload: pages,\n        },\n        classes: page === pages ? 'is-disabled' : '',\n      }\n    };\n  }\n\n  private getPaginationLinks(page, pages): Button[] {\n    let firstItem = 1;\n    const links: Button[] = [];\n    const limit = PAGE_LIMIT;\n    let last = limit;\n\n    if (pages > limit) {\n      const steps = Math.floor(limit / 2);\n      if (page > steps) {\n        firstItem = page - steps;\n      }\n\n      if ((page + steps) > pages) {\n        firstItem = (pages - limit) + 1;\n      }\n    } else {\n      last = pages;\n    }\n\n    let i;\n    for (i = 0; i < last; i += 1) {\n      const itemPage = firstItem + i;\n      links.push({\n        text: itemPage,\n        classes: itemPage === page ? 'is-disabled' : '',\n        anchor: {\n          payload: itemPage,\n        }\n      });\n    }\n\n    return links;\n  }\n}\n"]}

package/esm2022/lib/data-sources/gallery-results.ds.mjs

@@ -0,0 +1,103 @@
+import { DataSource } from '@net7/core';
+export class AwGalleryResultsDS extends DataSource {
+    constructor() {
+        super(...arguments);
+        this.addPagination = (page, totalPages, size) => {
+            const sizeOptions = [12, 24, 48];
+            this.pagination = {
+                first: { payload: `goto-${1}`, classes: page === 1 ? 'is-disabled' : '' },
+                prev: { payload: `goto-${page / 1 - 1}`, classes: page === 1 ? 'is-disabled' : '' },
+                next: { payload: `goto-${page / 1 + 1}`, classes: page === totalPages ? 'is-disabled' : '' },
+                last: { payload: `goto-${totalPages}`, classes: page === totalPages ? 'is-disabled' : '' },
+                links: this.makePagination(totalPages, page),
+                select: {
+                    label: 'Numero di risultati',
+                    options: sizeOptions.map((o) => ({
+                        text: o,
+                        selected: o === size,
+                    })),
+                    payload: 'select-size'
+                },
+            };
+        };
+        this.makePagination = (totalPages, currentPage) => {
+            /*
+              Called by this.unpackData() when this.options.page is defined.
+              Returns the data for <n7-pagination> component.
+            */
+            const result = [];
+            let limit = 5 - 1;
+            if (totalPages <= limit) {
+                limit = totalPages - 1;
+            }
+            // always push the first page
+            if (limit) {
+                let lastPage;
+                let firstPage;
+                if (currentPage > Math.floor(limit / 2)) {
+                    if (totalPages === 2) {
+                        lastPage = totalPages;
+                        firstPage = 1;
+                        // when currentPage is after half-point
+                        // (example: [ 14 ][ 15 ][!16!][ 17 ][ 18 ])
+                    }
+                    else if (currentPage < (totalPages - Math.floor(limit / 2))) {
+                        lastPage = currentPage / 1 + Math.floor(limit / 2);
+                        firstPage = currentPage / 1 - Math.floor(limit / 2);
+                    }
+                    else {
+                        lastPage = totalPages;
+                        firstPage = currentPage - limit + (totalPages - currentPage);
+                    }
+                }
+                else {
+                    // when currentPage is before half-point
+                    // (example: [ 1 ][!2!][ 3 ][ 4 ][ 5 ])
+                    lastPage = limit + 1;
+                    firstPage = 1;
+                }
+                // eslint-disable-next-line no-plusplus
+                for (let i = firstPage; i <= lastPage; i++) {
+                    result.push({
+                        text: String(i),
+                        payload: `page-${String(i)}`,
+                        classes: currentPage === i ? 'is-active' : ''
+                    });
+                }
+            }
+            else {
+                result.push({
+                    text: '1',
+                    payload: 'page-1',
+                    classes: currentPage === 1 ? 'is-active' : ''
+                });
+                // eslint-disable-next-line no-plusplus
+                for (let i = 1; i < totalPages; i++) {
+                    result.push({ text: String(i + 1), payload: `page-${String(i + 1)}`, classes: currentPage === i + 1 ? 'is-active' : '' });
+                }
+            }
+            return result;
+        };
+    }
+    transform(data) {
+        if (!data)
+            return null;
+        const { pageSize, currentPage } = this.options;
+        // if the data doesn't fit on one page, render the pagination component
+        if (data.length > pageSize) {
+            this.addPagination(currentPage, Math.ceil(data.length / pageSize), pageSize);
+        }
+        return {
+            res: data.slice(0, pageSize),
+            pagination: this.pagination
+        };
+    }
+    chunks(a, size) {
+        const results = [];
+        while (a.length) {
+            results.push(a.splice(0, size));
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gallery-results.ds.js","sourceRoot":"","sources":["../../../../../projects/n7-boilerplate-arianna/src/lib/data-sources/gallery-results.ds.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource } from '@net7/core';\n\nexport class AwGalleryResultsDS extends DataSource {\n  private pagination: any\n\n  protected transform(data) {\n    if (!data) return null;\n    const { pageSize, currentPage } = this.options;\n    // if the data doesn't fit on one page, render the pagination component\n    if (data.length > pageSize) {\n      this.addPagination(currentPage, Math.ceil(data.length / pageSize), pageSize);\n    }\n    return {\n      res: data.slice(0, pageSize),\n      pagination: this.pagination\n    };\n  }\n\n  public chunks(a, size) {\n    const results = [];\n    while (a.length) {\n      results.push(a.splice(0, size));\n    }\n    return results;\n  }\n\n  public addPagination = (page, totalPages, size) => {\n    const sizeOptions = [12, 24, 48];\n    this.pagination = {\n      first: { payload: `goto-${1}`, classes: page === 1 ? 'is-disabled' : '' },\n      prev: { payload: `goto-${page / 1 - 1}`, classes: page === 1 ? 'is-disabled' : '' },\n      next: { payload: `goto-${page / 1 + 1}`, classes: page === totalPages ? 'is-disabled' : '' },\n      last: { payload: `goto-${totalPages}`, classes: page === totalPages ? 'is-disabled' : '' },\n      links: this.makePagination(totalPages, page),\n      select: {\n        label: 'Numero di risultati',\n        options: sizeOptions.map((o) => ({\n          text: o,\n          selected: o === size,\n        })),\n        payload: 'select-size'\n      },\n    };\n  }\n\n  public makePagination = (totalPages, currentPage) => {\n    /*\n      Called by this.unpackData() when this.options.page is defined.\n      Returns the data for <n7-pagination> component.\n    */\n    const result = [];\n    let limit = 5 - 1;\n\n    if (totalPages <= limit) {\n      limit = totalPages - 1;\n    }\n\n    // always push the first page\n    if (limit) {\n      let lastPage: number; let\n        firstPage: number;\n      if (currentPage > Math.floor(limit / 2)) {\n        if (totalPages === 2) {\n          lastPage = totalPages;\n          firstPage = 1;\n          // when currentPage is after half-point\n          // (example: [ 14 ][ 15 ][!16!][ 17 ][ 18 ])\n        } else if (currentPage < (totalPages - Math.floor(limit / 2))) {\n          lastPage = currentPage / 1 + Math.floor(limit / 2);\n          firstPage = currentPage / 1 - Math.floor(limit / 2);\n        } else {\n          lastPage = totalPages;\n          firstPage = currentPage - limit + (totalPages - currentPage);\n        }\n      } else {\n        // when currentPage is before half-point\n        // (example: [ 1 ][!2!][ 3 ][ 4 ][ 5 ])\n        lastPage = limit + 1;\n        firstPage = 1;\n      }\n\n      // eslint-disable-next-line no-plusplus\n      for (let i = firstPage; i <= lastPage; i++) {\n        result.push({\n          text: String(i),\n          payload: `page-${String(i)}`,\n          classes: currentPage === i ? 'is-active' : ''\n        });\n      }\n    } else {\n      result.push({\n        text: '1',\n        payload: 'page-1',\n        classes: currentPage === 1 ? 'is-active' : ''\n      });\n      // eslint-disable-next-line no-plusplus\n      for (let i = 1; i < totalPages; i++) {\n        result.push({ text: String(i + 1), payload: `page-${String(i + 1)}`, classes: currentPage === i + 1 ? 'is-active' : '' });\n      }\n    }\n    return result;\n  }\n}\n"]}

package/esm2022/lib/data-sources/home-autocomplete.ds.mjs

@@ -0,0 +1,80 @@
+import { DataSource } from '@net7/core';
+import { helpers } from '@net7/boilerplate-common';
+export class AwHomeAutocompleteDS extends DataSource {
+    transform(data) {
+        const { response, query } = data;
+        const { results, totalCount } = response;
+        const { keys, config, paths } = this.options;
+        const labels = this.options.labels || {};
+        const itemIds = [];
+        const groups = {};
+        results.forEach(({ item, entity }) => {
+            const groupId = entity ? entity.typeOfEntity : item.document_type;
+            const groupConfig = keys[groupId];
+            const mainMetadata = groupConfig['main-metadata'];
+            const currentItem = item || entity;
+            if (!groups[groupId]) {
+                const { label, icon } = groupConfig;
+                groups[groupId] = {
+                    title: label,
+                    icon,
+                    classes: `color-${groupConfig['class-name']}`,
+                    items: [],
+                    type: groupId,
+                };
+            }
+            if (itemIds.indexOf(currentItem.id) === -1) {
+                const metadata = [];
+                if (currentItem.fields) {
+                    currentItem.fields.forEach(({ key, value }) => {
+                        if (mainMetadata && key === mainMetadata) {
+                            metadata.push({ key: helpers.prettifySnakeCase(key, labels[key]), value });
+                        }
+                    });
+                }
+                groups[groupId].items.push({
+                    title: currentItem.label,
+                    metadata,
+                    anchor: {
+                        href: `${paths[entity ? 'entitaBasePath' : 'schedaBasePath']}/${currentItem.id}/${helpers.slugify(currentItem.label)}`,
+                    },
+                });
+            }
+        });
+        const grouplist = Object.keys(groups).map((key) => ({
+            group: {
+                title: groups[key].title,
+                icon: groups[key].icon,
+                classes: groups[key].classes,
+            },
+            items: groups[key].items,
+        }));
+        return {
+            results: grouplist,
+            actions: grouplist.length > 0 ? {
+                showMore: {
+                    text: `Visualizza tutti i ${totalCount} risultati`,
+                    anchor: {
+                        href: paths.searchBasePath,
+                        queryParams: {
+                            query,
+                        },
+                    },
+                },
+            } : {
+                showMore: {
+                    text: 'Cerca in tutti i campi',
+                    anchor: {
+                        href: paths.searchBasePath,
+                        queryParams: {
+                            query, // Query string
+                            'query-all': 1, // "Cerca in tutti i campi delle schede"
+                        },
+                    },
+                },
+            },
+            fallback: ((config.get('home-layout') || {})['top-hero'] || {}).fallback,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/data-sources/home-facets-wrapper.ds.mjs

@@ -0,0 +1,190 @@
+import { DataSource } from '@net7/core';
+import tippy from 'tippy.js';
+export class AwHomeFacetsWrapperDS extends DataSource {
+    constructor() {
+        super(...arguments);
+        this.autoComplete = {}; // autocomplete data for each facet
+        this.lockedFacets = {}; // locked means that the eye cannot be closed
+        // store the last response so the component can be rendered again with the same data
+        this.lastData = {};
+        this.closedEyes = []; // list of closed eyes
+        this.openTippy = ''; // tipe of entity of the currently open tippy
+        this.tippyMaker = (id) => {
+            /*
+              Builds or updates Tippy for the input in use (id)
+            */
+            const newId = id.replace(/ /g, '-');
+            // create data for this facet
+            if (!this.autoComplete[newId]) {
+                this.autoComplete[newId] = {
+                    tippy: undefined, // tippy data / config
+                    open: true, // show or hide tippy
+                };
+                const ac = this.autoComplete[newId];
+                const getContent = () => {
+                    const contentNode = document.getElementsByClassName('aw-simple-autocomplete__template')[0];
+                    contentNode.setAttribute('style', 'display: block');
+                    return contentNode;
+                };
+                if (!ac.tippy) {
+                    // target the correct this.autoComplete[id] input class
+                    const target = document.getElementsByClassName(newId)[1];
+                    ac.tippy = tippy(target, {
+                        content: getContent(),
+                        trigger: 'manual',
+                        interactive: true,
+                        arrow: false,
+                        flip: false,
+                        appendTo: 'parent',
+                        theme: 'light-border aw-home__facet-tippy',
+                        placement: 'bottom-start',
+                        maxWidth: '100%',
+                    }); // attach tippy to input type text
+                }
+            }
+            const ac = this.autoComplete[newId];
+            if (ac.tippy) {
+                ac.tippy.show();
+            }
+        };
+        this.tippyClose = (id) => {
+            const newId = id.replace(/ /g, '-');
+            if (this.autoComplete[newId]) {
+                const ac = this.autoComplete[newId];
+                if (ac.tippy) {
+                    ac.tippy.hide();
+                }
+            }
+        };
+    }
+    transform(data) {
+        this.lastData = data;
+        const headers = [];
+        const inputs = [];
+        const links = [];
+        const facetData = data;
+        const { pageConfig, paths } = this.options || {};
+        const { lockedFacets } = this; // locked means that the eye cannot be closed
+        const { closedEyes } = this; // list of closed eyes
+        // when facet data changes, destroy every tippy and reset autocomplete data.
+        Object.keys(this.autoComplete).forEach((id) => {
+            if (this.autoComplete[id] && this.autoComplete[id].tippy) {
+                this.autoComplete[id].tippy.destroy(); // destroy
+            }
+        });
+        this.autoComplete = {}; // reset data
+        facetData.forEach((facet, j) => {
+            /*
+             For each facet on back-end, push a header-component
+             and a facet-component (search input only) to each array.
+             ---//---
+             # LOGIC:
+             Each facet can be "locked" or "enabled".
+             if a facet is locked, it means that it cannot be enabled or disabled.
+             if a facet is enabled or disabled it means that the filter is active or inactive.
+      
+             there are 2 ways that a facet can be "locked"
+               1. When a bubble of the same type is selected in the chart
+               2. When that facet is the only enabled facet
+      
+             The first case is managed by pushing the selected bubble's ID to the corresponding array
+             of lockedFacets.
+             The second case is managed by pushing a "LOCK_LAST" string
+             to the lockedFacets array of the last
+             enabled facet.
+            */
+            Object.keys(lockedFacets).forEach((key) => {
+                // clear all locked facets arrays from "LOCK_LAST" values (reset all locks)
+                const index = lockedFacets[key].indexOf('LOCK_LAST');
+                if (index >= 0) {
+                    lockedFacets[key].splice(index, 1);
+                }
+            });
+            if (closedEyes) {
+                if (closedEyes.length === facetData.length - 1) {
+                    const lastFacet = facetData.find((f) => !closedEyes.includes(f.type.replace(/ /g, '-')));
+                    if (lastFacet) {
+                        if (closedEyes[lastFacet.type]) {
+                            lockedFacets[lastFacet.type].push('LOCK_LAST');
+                        }
+                        else {
+                            lockedFacets[lastFacet.type] = ['LOCK_LAST'];
+                        }
+                    }
+                }
+                if (closedEyes.includes(facet.type.replace(/ /g, '-'))) { // check if the eyes are open
+                    facet.enabled = false;
+                }
+                else {
+                    facet.enabled = true;
+                }
+            }
+            if (Object.keys(lockedFacets).length) { // check if bubble chart wants to lock this facet
+                if (lockedFacets[facet.type] && lockedFacets[facet.type].length > 0) {
+                    // if bubble chart say lock this facet, lock it
+                    facet.locked = true;
+                }
+                else {
+                    facet.locked = false;
+                }
+            }
+            else {
+                facet.locked = false;
+            }
+            const headerClasses = [];
+            const iconClasses = [facet.icon];
+            if (!facet.enabled) {
+                headerClasses.push('is-disabled');
+            }
+            if (facet['class-name']) {
+                headerClasses.push(`color-${facet['class-name']}`);
+                iconClasses.push(`color-${facet['class-name']}`);
+            }
+            // make array of headers data
+            headers.push({
+                iconLeft: iconClasses.join(' '),
+                text: facet.label,
+                additionalText: facet.count,
+                iconRight: facet.enabled ? 'n7-icon-eye' : 'n7-icon-eye-slash',
+                classes: headerClasses.join(' ')
+                    + (facet.locked
+                        ? ' is-blocked'
+                        : ' not-blocked'),
+                payload: facet.locked === true ? null : facet.type.replace(/ /g, '-'),
+            });
+            // make array of inputs data
+            inputs.push({
+                sections: [
+                    {
+                        inputs: [
+                            {
+                                id: `${facet.type.replace(/ /g, '-')}-${j}`,
+                                type: 'text',
+                                placeholder: facet['input-placeholder'],
+                                icon: 'n7-icon-search',
+                                disabled: !facet.enabled,
+                                inputPayload: `${String(facet.type.replace(/ /g, '-'))}-search`,
+                                iconPayload: `${String(facet.type.replace(/ /g, '-'))}-search`,
+                                enterPayload: `${String(facet.type.replace(/ /g, '-'))}-search`,
+                                classes: `${String(facet.type.replace(' ', '-'))}-search`,
+                            },
+                        ],
+                    },
+                ],
+            });
+            if (pageConfig?.['view-all-links']?.enabled) {
+                const { label } = pageConfig['view-all-links'];
+                links.push({
+                    label: label || 'Visualizza tutti',
+                    path: paths.searchBasePath,
+                    queryParams: {
+                        'query-links': facet.type.replace(/ /g, '-')
+                    }
+                });
+            }
+        });
+        // zipping arrays to render widgets with separate data (see home-layout.html)
+        return headers.map((h, i) => ({ header: h, input: inputs[i], link: links[i] || null }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"home-facets-wrapper.ds.js","sourceRoot":"","sources":["../../../../../projects/n7-boilerplate-arianna/src/lib/data-sources/home-facets-wrapper.ds.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource } from '@net7/core';\nimport tippy from 'tippy.js';\n\nexport class AwHomeFacetsWrapperDS extends DataSource {\n  private autoComplete = {}; // autocomplete data for each facet\n\n  public lockedFacets = {}; // locked means that the eye cannot be closed\n\n  // store the last response so the component can be rendered again with the same data\n  public lastData = {};\n\n  public closedEyes = []; // list of closed eyes\n\n  public openTippy = ''; // tipe of entity of the currently open tippy\n\n  protected transform(data) {\n    this.lastData = data;\n    const headers: any[] = [];\n    const inputs: any[] = [];\n    const links: any[] = [];\n    const facetData = data;\n    const { pageConfig, paths } = this.options || {};\n    const { lockedFacets } = this; // locked means that the eye cannot be closed\n    const { closedEyes } = this; // list of closed eyes\n\n    // when facet data changes, destroy every tippy and reset autocomplete data.\n    Object.keys(this.autoComplete).forEach((id) => {\n      if (this.autoComplete[id] && this.autoComplete[id].tippy) {\n        this.autoComplete[id].tippy.destroy(); // destroy\n      }\n    });\n    this.autoComplete = {}; // reset data\n\n    facetData.forEach((facet, j) => {\n      /*\n       For each facet on back-end, push a header-component\n       and a facet-component (search input only) to each array.\n       ---//---\n       # LOGIC:\n       Each facet can be \"locked\" or \"enabled\".\n       if a facet is locked, it means that it cannot be enabled or disabled.\n       if a facet is enabled or disabled it means that the filter is active or inactive.\n\n       there are 2 ways that a facet can be \"locked\"\n         1. When a bubble of the same type is selected in the chart\n         2. When that facet is the only enabled facet\n\n       The first case is managed by pushing the selected bubble's ID to the corresponding array\n       of lockedFacets.\n       The second case is managed by pushing a \"LOCK_LAST\" string\n       to the lockedFacets array of the last\n       enabled facet.\n      */\n      Object.keys(lockedFacets).forEach((key) => {\n        // clear all locked facets arrays from \"LOCK_LAST\" values (reset all locks)\n        const index = lockedFacets[key].indexOf('LOCK_LAST');\n        if (index >= 0) {\n          lockedFacets[key].splice(index, 1);\n        }\n      });\n      if (closedEyes) {\n        if (closedEyes.length === facetData.length - 1) {\n          const lastFacet = facetData.find((f) => !closedEyes.includes(f.type.replace(/ /g, '-')));\n          if (lastFacet) {\n            if (closedEyes[lastFacet.type]) {\n              lockedFacets[lastFacet.type].push('LOCK_LAST');\n            } else {\n              lockedFacets[lastFacet.type] = ['LOCK_LAST'];\n            }\n          }\n        }\n        if (closedEyes.includes(facet.type.replace(/ /g, '-'))) { // check if the eyes are open\n          facet.enabled = false;\n        } else {\n          facet.enabled = true;\n        }\n      }\n      if (Object.keys(lockedFacets).length) { // check if bubble chart wants to lock this facet\n        if (lockedFacets[facet.type] && lockedFacets[facet.type].length > 0) {\n          // if bubble chart say lock this facet, lock it\n          facet.locked = true;\n        } else {\n          facet.locked = false;\n        }\n      } else {\n        facet.locked = false;\n      }\n      const headerClasses = [];\n      const iconClasses = [facet.icon];\n      if (!facet.enabled) { headerClasses.push('is-disabled'); }\n      if (facet['class-name']) {\n        headerClasses.push(`color-${facet['class-name']}`);\n        iconClasses.push(`color-${facet['class-name']}`);\n      }\n      // make array of headers data\n      headers.push({\n        iconLeft: iconClasses.join(' '),\n        text: facet.label,\n        additionalText: facet.count,\n        iconRight: facet.enabled ? 'n7-icon-eye' : 'n7-icon-eye-slash',\n        classes:\n          headerClasses.join(' ')\n          + (facet.locked\n            ? ' is-blocked'\n            : ' not-blocked'),\n        payload: facet.locked === true ? null : facet.type.replace(/ /g, '-'),\n      });\n      // make array of inputs data\n      inputs.push({\n        sections: [\n          {\n            inputs: [\n              {\n                id: `${facet.type.replace(/ /g, '-')}-${j}`,\n                type: 'text',\n                placeholder: facet['input-placeholder'],\n                icon: 'n7-icon-search',\n                disabled: !facet.enabled,\n                inputPayload: `${String(facet.type.replace(/ /g, '-'))}-search`,\n                iconPayload: `${String(facet.type.replace(/ /g, '-'))}-search`,\n                enterPayload: `${String(facet.type.replace(/ /g, '-'))}-search`,\n                classes: `${String(facet.type.replace(' ', '-'))}-search`,\n              },\n            ],\n          },\n        ],\n      });\n      if (pageConfig?.['view-all-links']?.enabled) {\n        const { label } = pageConfig['view-all-links'];\n        links.push({\n          label: label || 'Visualizza tutti',\n          path: paths.searchBasePath,\n          queryParams: {\n            'query-links': facet.type.replace(/ /g, '-')\n          }\n        });\n      }\n    });\n\n    // zipping arrays to render widgets with separate data (see home-layout.html)\n    return headers.map((h, i) => ({ header: h, input: inputs[i], link: links[i] || null }));\n  }\n\n  public tippyMaker = (id) => {\n    /*\n      Builds or updates Tippy for the input in use (id)\n    */\n    const newId = id.replace(/ /g, '-');\n    // create data for this facet\n    if (!this.autoComplete[newId]) {\n      this.autoComplete[newId] = {\n        tippy: undefined, // tippy data / config\n        open: true, // show or hide tippy\n      };\n      const ac = this.autoComplete[newId];\n      const getContent = () => {\n        const contentNode = document.getElementsByClassName(\n          'aw-simple-autocomplete__template',\n        )[0];\n        contentNode.setAttribute('style', 'display: block');\n        return contentNode;\n      };\n\n      if (!ac.tippy) {\n        // target the correct this.autoComplete[id] input class\n        const target = document.getElementsByClassName(newId)[1];\n        ac.tippy = tippy(target, {\n          content: getContent(),\n          trigger: 'manual',\n          interactive: true,\n          arrow: false,\n          flip: false,\n          appendTo: 'parent',\n          theme: 'light-border aw-home__facet-tippy',\n          placement: 'bottom-start',\n          maxWidth: '100%',\n        }); // attach tippy to input type text\n      }\n    }\n    const ac = this.autoComplete[newId];\n    if (ac.tippy) {\n      ac.tippy.show();\n    }\n  };\n\n  public tippyClose = (id) => {\n    const newId = id.replace(/ /g, '-');\n    if (this.autoComplete[newId]) {\n      const ac = this.autoComplete[newId];\n      if (ac.tippy) {\n        ac.tippy.hide();\n      }\n    }\n  };\n}\n"]}