@gouvfr/dsfr-nexus/src/interpret/dsfr/part/page/resource/navigation-interpreter.js

Le module `dsfr-nexus` est l'interface de ligne de commande (CLI) centrale du Système de Design de l’État - DSFR. Il offre des outils pour gérer et compiler les ressources du DSFR

import { log, normalizeId } from '@gouvfr/dsfr-forge';

class NavigationInterpreter {
  constructor (state, data) {
    this._state = state;
    this._data = data;
  }

  async resolve () {
    this._interpretMain();
    this._interpretSidemenu();
  }

  _interpretMain (main) {
    this._data.main.items = this._data.main.items.map(item => this._mapMainItem(item)).filter(item => item);
  }

  _mapMainItem (item) {
    switch (item.type) {
      case 'link':
        return {
          ...this._state.resolveItem(item),
          type: 'link'
        };

      case 'menu':
        return this._interpretMenu(item);

      case 'mega-menu':
        return this._interpretMegaMenu(item);
    }
  }

  _interpretMenu (menu) {
    const node = this._state.resolveItem(menu);

    return {
      type: 'menu',
      id: node.id || normalizeId(menu.path),
      text: node.text,
      url: node.url,
      isCurrent: node.isCurrent,
      items: this._interpretItems(menu)
    };
  }

  _interpretMegaMenu (item) {
    const node = this._state.resolveItem(item);
    const categories = item.categories ? item.categories.map(category => this._interpretCategory(category)) : this._resolveCategories(item.path);

    return {
      type: 'mega-menu',
      id: node.id || normalizeId(item.path),
      text: node.text,
      url: node.url,
      isCurrent: node.isCurrent,
      categories: categories
    };
  }

  _resolveCategories (path) {
    return this._state.resolveItems(path).map(category => this._interpretCategory(category));
  }

  _interpretCategory (category) {
    const node = this._state.resolveItem(category);

    return {
      id: node.id || normalizeId(category.path),
      text: node.text,
      url: node.url,
      isCurrent: node.isCurrent,
      items: this._interpretItems(category)
    };
  }

  _interpretItems (wrapper) {
    if (wrapper.items) {
      const items = wrapper.items.map(item => this._state.resolveItem(item));
      if (items && items.length) return items;
    }

    const items = this._state.resolveItems(wrapper.path, wrapper.rank);
    if (items && items.length) return items;
  }

  _interpretSidemenu () {
    const sidemenu = this._getMatch();
    if (!sidemenu) {
      this._data.sidemenu = undefined;
      return;
    }

    const node = this._state.resolveItem({path: sidemenu.match});

    const sort = sidemenu.sort?.split(',').map(s => s.trim()).filter(s => s.length > 0);

    const items = this._state.resolveItems(sidemenu.match, sidemenu.rank, sort?.[0]);

    const isCollapsible = sidemenu.isCollapsible !== false;

    if (!isNaN(sidemenu.depth) && sidemenu.depth >= 2) {
      items.forEach(item => {
        const items2 = this._state.resolveItems(item.path, sidemenu.rank, sort?.[1] ?? sort?.[0]);
        if (items2.length) {
          item.type = 'menu';
          item.isCollapsible = isCollapsible;

          if (sidemenu.depth >= 3) {
            items2.forEach(item => {
              const items3 = this._state.resolveItems(item.path, sidemenu.rank, sort?.[2] ?? sort?.[0]);
              if (items3.length) {
                item.type = 'menu';
                item.isCollapsible = isCollapsible;
                item.items = items3;
              }
            });
          }
          item.items = items2;
        }
      });
    }

    this._data.sidemenu = {
      buttonLabel: this._data.sidemenu.buttonLabel,
      titleLabel: this._data.sidemenu.titleLabel,
      text: node.text,
      items: items
    };
  }

  _getMatch () {
    for (const sidemenu of this._data.sidemenu.items) {
      if (this._state.path.indexOf(sidemenu.match) === 0) {
        return sidemenu;
      }
    }

    return null;
  }
}

export { NavigationInterpreter };