@jpmorganchase/mosaic-plugins 0.1.0-beta.8 → 0.1.0-beta.81

package/dist/SidebarPlugin.js

@@ -1,341 +1,302 @@
-function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-        var info = gen[key](arg);
-        var value = info.value;
-    } catch (error) {
-        reject(error);
-        return;
-    }
-    if (info.done) {
-        resolve(value);
-    } else {
-        Promise.resolve(value).then(_next, _throw);
-    }
-}
-function _asyncToGenerator(fn) {
-    return function() {
-        var self = this, args = arguments;
-        return new Promise(function(resolve, reject) {
-            var gen = fn.apply(self, args);
-            function _next(value) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-            }
-            function _throw(err) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-            }
-            _next(undefined);
-        });
-    };
-}
-function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
-function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-import regeneratorRuntime from "regenerator-runtime";
-import path from "path";
+import path from 'path';
+import { sidebarSortConfigSchema } from '@jpmorganchase/mosaic-schemas';
+import { cloneDeep, escapeRegExp } from 'lodash-es';
+import { isDataNode, isGroupNode, sortSidebarData } from './utils/sortSidebarData.js';
 function createFileGlob(patterns, pageExtensions) {
     if (Array.isArray(patterns)) {
-        return patterns.map(function(pattern) {
-            return createFileGlob(pattern, pageExtensions);
-        });
+        return patterns.map(pattern => createFileGlob(pattern, pageExtensions));
     }
     if (pageExtensions.length === 1) {
-        return "".concat(patterns).concat(pageExtensions[0]);
+        return `${patterns}${pageExtensions[0]}`;
     }
-    return "".concat(patterns, "{").concat(pageExtensions.join(","), "}");
+    return `${patterns}{${pageExtensions.join(',')}}`;
 }
-function isSubfolderIndex(page, dirName) {
-    return page.fullPath.split("/").length === String(dirName).split("/").length + 2;
+function getPageLevel(page) {
+    return page.route.split('/').length - 2;
 }
-function sortFn(pageA, pageB, dirName) {
-    // Always pin /index to the front
-    var route = "".concat(dirName, "/index");
-    if (pageA.route === route) {
-        return -1;
-    }
-    if (pageB.route === route) {
-        return 1;
-    }
-    return (pageB.sidebar && pageB.sidebar.priority ? pageB.sidebar.priority : -1) - (pageA.sidebar && pageA.sidebar.priority ? pageA.sidebar.priority : -1);
+function sortByPathLevel(pathA, pathB) {
+    const pathALevel = pathA.split('/').length;
+    const pathBLevel = pathB.split('/').length;
+    return pathBLevel - pathALevel;
 }
-function filterFn(page) {
-    return !(page.sidebar && page.sidebar.exclude);
+/**
+ * Given the sharedSortConfig
+ * 1. find the field specified by 'field' in the sort config
+ * 2. transform the field value into the type specified by 'dataType'
+ * @param page
+ * @param sharedSortConfig
+ * @returns transformed field value
+ */
+function getSortFieldData(page, sharedSortConfig) {
+    let fieldData;
+    if (sharedSortConfig !== undefined) {
+        const { field, dataType = 'string' } = sharedSortConfig;
+        field
+            .replace(/^(?:\.\.\/|\.\/)+/, '')
+            .split('/')
+            .forEach(part => {
+            const source = fieldData === undefined ? page : fieldData;
+            if (Object.prototype.hasOwnProperty.call(source, part)) {
+                fieldData = source[part];
+            }
+        });
+        switch (dataType) {
+            case 'date':
+                fieldData = new Date(fieldData).getTime(); // call getTime to convert to a number
+                break;
+            case 'string':
+                fieldData = String(fieldData);
+                break;
+            case 'number':
+                fieldData = Number(fieldData);
+                break;
+            default:
+                fieldData = String(fieldData);
+        }
+    }
+    return fieldData;
 }
+const createPageTest = (ignorePages, pageExtensions) => {
+    const extTest = new RegExp(`${pageExtensions.map(ext => escapeRegExp(ext)).join('|')}$`);
+    const ignoreTest = new RegExp(`${ignorePages.map(ignore => escapeRegExp(ignore)).join('|')}$`);
+    return file => !ignoreTest.test(file) && extTest.test(file) && !path.basename(file).startsWith('.');
+};
+/**
+ * Directories create groups of pages, the index file within that group is assigned GROUP_DEFAULT_PRIORITY
+ * to ensure it comes first. This can be overriden by the metadata to move the position of the default page.
+ */
+const GROUP_DEFAULT_PRIORITY = 999;
 /**
- * Sorts the pages in a folder by priority and then exports a JSON file (name: `options.filename`) with the
+ * Sorts the pages in a folder by priority and then exports a JSON file with the
  * sidebar tree from that directory downwards and adds sidebar data into frontmatter for each page.
- */ var SidebarPlugin = {
-    $beforeSend: function $beforeSend(mutableFilesystem, param, options) {
-        var config = param.config, serialiser = param.serialiser, ignorePages = param.ignorePages, pageExtensions = param.pageExtensions;
-        return _asyncToGenerator(/*#__PURE__*/ regeneratorRuntime.mark(function _callee() {
-            var setPageRefs, setChildPageRefs, _setChildPageRefs, addSidebarDataToFrontmatter, dirs, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, dirName, sidebarFilePath, pages, i;
-            return regeneratorRuntime.wrap(function _callee$(_ctx) {
-                while(1)switch(_ctx.prev = _ctx.next){
-                    case 0:
-                        setPageRefs = function _setPageRefs(sidebarFilePath, page, i) {
-                            config.setRef(sidebarFilePath, [
-                                "pages",
-                                "".concat(i),
-                                "id",
-                                "$ref"
-                            ], "".concat(page.fullPath, "#/route"));
-                            var label = page.sidebar && page.sidebar.label ? "".concat(page.fullPath, "#/sidebar/label") : "".concat(page.fullPath, "#/title");
-                            config.setRef(sidebarFilePath, [
-                                "pages",
-                                "".concat(i),
-                                "name",
-                                "$ref"
-                            ], label);
-                            config.setRef(sidebarFilePath, [
-                                "pages",
-                                "".concat(i),
-                                "data",
-                                "link",
-                                "$ref"
-                            ], "".concat(page.fullPath, "#/route"));
-                        };
-                        setChildPageRefs = function _setChildPageRefs1(page, dirName, i, sidebarFilePath) {
-                            return _setChildPageRefs.apply(this, arguments);
-                        };
-                        _setChildPageRefs = function __setChildPageRefs() {
-                            _setChildPageRefs = _asyncToGenerator(/*#__PURE__*/ regeneratorRuntime.mark(function _callee(page, dirName, i, sidebarFilePath) {
-                                var childDirName, childNodeSidebarPath, childPages, j;
-                                return regeneratorRuntime.wrap(function _callee$(_ctx) {
-                                    while(1)switch(_ctx.prev = _ctx.next){
-                                        case 0:
-                                            if (!isSubfolderIndex(page, dirName)) {
-                                                _ctx.next = 11;
-                                                break;
-                                            }
-                                            childDirName = path.posix.dirname(page.fullPath);
-                                            childNodeSidebarPath = path.posix.join(childDirName, options.filename);
-                                            _ctx.t0 = Promise;
-                                            _ctx.next = 6;
-                                            return mutableFilesystem.promises.glob(createFileGlob([
-                                                "*",
-                                                "*/index"
-                                            ], pageExtensions), {
-                                                onlyFiles: true,
-                                                cwd: String(childDirName),
-                                                ignore: ignorePages.map(function(ignore) {
-                                                    return "**/".concat(ignore);
-                                                })
-                                            });
-                                        case 6:
-                                            _ctx.t1 = _ctx.sent.map(function() {
-                                                var _ref = _asyncToGenerator(/*#__PURE__*/ regeneratorRuntime.mark(function _callee(pagePath) {
-                                                    var deserialisedPage;
-                                                    return regeneratorRuntime.wrap(function _callee$(_ctx) {
-                                                        while(1)switch(_ctx.prev = _ctx.next){
-                                                            case 0:
-                                                                _ctx.t0 = serialiser;
-                                                                _ctx.t1 = pagePath;
-                                                                _ctx.next = 4;
-                                                                return mutableFilesystem.promises.readFile(pagePath);
-                                                            case 4:
-                                                                _ctx.t2 = _ctx.sent;
-                                                                _ctx.next = 7;
-                                                                return _ctx.t0.deserialise.call(_ctx.t0, _ctx.t1, _ctx.t2);
-                                                            case 7:
-                                                                deserialisedPage = _ctx.sent;
-                                                                return _ctx.abrupt("return", deserialisedPage);
-                                                            case 9:
-                                                            case "end":
-                                                                return _ctx.stop();
-                                                        }
-                                                    }, _callee);
-                                                }));
-                                                return function(pagePath) {
-                                                    return _ref.apply(this, arguments);
-                                                };
-                                            }());
-                                            _ctx.next = 9;
-                                            return _ctx.t0.all.call(_ctx.t0, _ctx.t1);
-                                        case 9:
-                                            childPages = _ctx.sent.filter(function(filterPage) {
-                                                return filterFn(filterPage);
-                                            });
-                                            if (childPages.length > 1) {
-                                                for(j = 1; j < childPages.length; j++){
-                                                    config.setRef(sidebarFilePath, [
-                                                        "pages",
-                                                        "".concat(i),
-                                                        "childNodes",
-                                                        "".concat(j - 1),
-                                                        "$ref"
-                                                    ], "".concat(childNodeSidebarPath, "#/pages/").concat(j));
-                                                }
-                                            }
-                                        case 11:
-                                        case "end":
-                                            return _ctx.stop();
-                                    }
-                                }, _callee);
-                            }));
-                            return _setChildPageRefs.apply(this, arguments);
-                        };
-                        addSidebarDataToFrontmatter = function _addSidebarDataToFrontmatter(page, dirName) {
-                            var _posix;
-                            var dirNameLevels = String(dirName).split("/").filter(function(level) {
-                                return level;
-                            });
-                            var sidebarRootDir = (_posix = path.posix).join.apply(_posix, [
-                                "/"
-                            ].concat(_toConsumableArray(dirNameLevels.slice(0, dirNameLevels.length < 3 ? dirNameLevels.length : 3)), [
-                                "/"
-                            ]));
-                            config.setRef(String(page.fullPath), [
-                                "sidebarData",
-                                "$ref"
-                            ], path.posix.join(String(sidebarRootDir), options.filename, "#", "pages"));
-                        };
-                        ;
-                        ;
-                        ;
-                        ;
-                        _ctx.next = 10;
-                        return mutableFilesystem.promises.glob("**", {
-                            onlyDirectories: true,
-                            cwd: "/"
-                        });
-                    case 10:
-                        dirs = _ctx.sent;
-                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                        _ctx.prev = 12;
-                        _iterator = dirs[Symbol.iterator]();
-                    case 14:
-                        if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
-                            _ctx.next = 30;
-                            break;
-                        }
-                        dirName = _step.value;
-                        sidebarFilePath = path.posix.join(String(dirName), options.filename);
-                        _ctx.t0 = Promise;
-                        _ctx.next = 20;
-                        return mutableFilesystem.promises.glob(createFileGlob([
-                            "*",
-                            "*/index"
-                        ], pageExtensions), {
-                            onlyFiles: true,
-                            cwd: String(dirName),
-                            ignore: ignorePages.map(function(ignore) {
-                                return "**/".concat(ignore);
-                            })
-                        });
-                    case 20:
-                        _ctx.t1 = _ctx.sent.map(function() {
-                            var _ref = _asyncToGenerator(/*#__PURE__*/ regeneratorRuntime.mark(function _callee(pagePath) {
-                                var deserialisedPage;
-                                return regeneratorRuntime.wrap(function _callee$(_ctx) {
-                                    while(1)switch(_ctx.prev = _ctx.next){
-                                        case 0:
-                                            _ctx.t0 = serialiser;
-                                            _ctx.t1 = pagePath;
-                                            _ctx.next = 4;
-                                            return mutableFilesystem.promises.readFile(pagePath);
-                                        case 4:
-                                            _ctx.t2 = _ctx.sent;
-                                            _ctx.next = 7;
-                                            return _ctx.t0.deserialise.call(_ctx.t0, _ctx.t1, _ctx.t2);
-                                        case 7:
-                                            deserialisedPage = _ctx.sent;
-                                            return _ctx.abrupt("return", deserialisedPage);
-                                        case 9:
-                                        case "end":
-                                            return _ctx.stop();
-                                    }
-                                }, _callee);
-                            }));
-                            return function(pagePath) {
-                                return _ref.apply(this, arguments);
-                            };
-                        }());
-                        _ctx.next = 23;
-                        return _ctx.t0.all.call(_ctx.t0, _ctx.t1);
-                    case 23:
-                        pages = _ctx.sent.filter(function(page) {
-                            return filterFn(page);
-                        }).sort(function(pageA, pageB) {
-                            return sortFn(pageA, pageB, dirName);
-                        });
-                        for(i = 0; i < pages.length; i++){
-                            setPageRefs(sidebarFilePath, pages[i], i);
-                            setChildPageRefs(pages[i], dirName, i, sidebarFilePath);
-                            addSidebarDataToFrontmatter(pages[i], dirName);
-                        }
-                        _ctx.next = 27;
-                        return mutableFilesystem.promises.writeFile(sidebarFilePath, "[]");
-                    case 27:
-                        _iteratorNormalCompletion = true;
-                        _ctx.next = 14;
-                        break;
-                    case 30:
-                        _ctx.next = 36;
-                        break;
-                    case 32:
-                        _ctx.prev = 32;
-                        _ctx.t2 = _ctx["catch"](12);
-                        _didIteratorError = true;
-                        _iteratorError = _ctx.t2;
-                    case 36:
-                        _ctx.prev = 36;
-                        _ctx.prev = 37;
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
+ *
+ * Additionally, add to frontmatter
+ * navigation -> prev -> { title, route }
+ * navigation -> next -> { title, route }
+ * to define the previous/next page in the page sequence, as defined by sidebar label and priority
+ */
+const SidebarPlugin = {
+    async $afterSource(pages, { ignorePages = [], pageExtensions = [] }) {
+        for (const page of pages) {
+            const isNonHiddenPage = createPageTest(ignorePages, pageExtensions);
+            if (!isNonHiddenPage(page.fullPath)) {
+                continue;
+            }
+            let sidebar = {
+                label: page.title,
+                groupLabel: page?.sidebar?.label || page.title,
+                ...page?.sidebar
+            };
+            page.sidebar = sidebar;
+        }
+        return pages;
+    },
+    async $beforeSend(mutableFilesystem, { config, serialiser, ignorePages, pageExtensions }, { filename = 'sidebar.json', rootDirGlob = '*' }) {
+        /**
+         * Create a list of pages that should be used to build a sidebar.json
+         * @param dirName - root path of sidebar
+         */
+        async function createPageList(rootDir) {
+            const isChildOfRootDir = pagePath => {
+                const pageDir = path.dirname(pagePath);
+                return pageDir.indexOf(rootDir) === 0;
+            };
+            const pagePaths = (await mutableFilesystem.promises.glob(createFileGlob(['**'], pageExtensions), {
+                cwd: String(rootDir),
+                ignore: ignorePages.map(ignore => `**/${ignore}`)
+            }));
+            const filteredPagePaths = pagePaths.filter(isChildOfRootDir);
+            const pageList = await Promise.all(filteredPagePaths.map(async (pagePath) => {
+                return mutableFilesystem.promises.readFile(pagePath).then(serializedContent => {
+                    return serialiser.deserialise(pagePath, serializedContent);
+                });
+            }));
+            return pageList;
+        }
+        /**
+         * Group the pages into parent/child hierarchy
+         * @param pages - sidebar pages
+         */
+        function createGroupMap(pages) {
+            const sortConfigPages = {};
+            return pages.reduce((result, page) => {
+                const name = page.sidebar?.label || page.title;
+                const sharedSortConfig = page?.sharedConfig?.sidebar?.sort;
+                if (sharedSortConfig) {
+                    try {
+                        sidebarSortConfigSchema.parse(sharedSortConfig);
+                        sortConfigPages[`${path.posix.dirname(page.fullPath)}`] = sharedSortConfig;
+                    }
+                    catch (e) {
+                        /**
+                         * Don't throw a PluginError here as this will stop the sidebar being generated.
+                         * Plugins need a way to log errors/warnings without exceptions
+                         */
+                        console.error(`[Mosaic] SidebarPlugin - Invalid sidebar sort config found in ${page.fullPath}`);
+                    }
+                }
+                const priority = page.sidebar?.priority;
+                const isGroupDefaultPage = /\/index$/.test(page.route);
+                const groupPath = path.posix.dirname(page.fullPath);
+                let newChildNode = {
+                    id: page.route,
+                    kind: 'data',
+                    fullPath: page.fullPath,
+                    name,
+                    priority: isGroupDefaultPage ? priority || GROUP_DEFAULT_PRIORITY : priority,
+                    data: { level: getPageLevel(page), link: page.route }
+                };
+                const currentChildNodes = Object.prototype.hasOwnProperty.call(result, groupPath)
+                    ? result[groupPath].childNodes
+                    : [];
+                let newGroupNode = {
+                    ...result[groupPath],
+                    id: path.posix.dirname(page.route),
+                    kind: 'group',
+                    childNodes: [...currentChildNodes, newChildNode]
+                };
+                if (isGroupDefaultPage) {
+                    newGroupNode = {
+                        ...newGroupNode,
+                        name: page.sidebar?.groupLabel || name,
+                        priority
+                    };
+                }
+                if (!isGroupDefaultPage && sortConfigPages[groupPath] !== undefined) {
+                    const fieldData = getSortFieldData(page, sortConfigPages[groupPath]);
+                    newChildNode.sharedSortConfig = {
+                        ...sortConfigPages[groupPath],
+                        fieldData
+                    };
+                }
+                result[groupPath] = newGroupNode;
+                return result;
+            }, {});
+        }
+        /**
+         * Link the group map to their parents
+         * @param groupMap - unlinked groups of pages
+         * @param dirName - root path of sidebar
+         */
+        function linkGroupMap(groupMap, dirName) {
+            const linkedGroupMap = cloneDeep(groupMap);
+            const sortedGroupMapKeys = Object.keys(linkedGroupMap).sort(sortByPathLevel);
+            sortedGroupMapKeys.forEach(groupPath => {
+                let parentGroupPath = path.posix.dirname(groupPath);
+                if (linkedGroupMap[parentGroupPath] === undefined) {
+                    return;
+                }
+                linkedGroupMap[parentGroupPath].childNodes = [
+                    ...linkedGroupMap[parentGroupPath].childNodes,
+                    linkedGroupMap[groupPath]
+                ];
+            });
+            return [linkedGroupMap[dirName]];
+        }
+        /**
+         * Link each page to a sidebar.json file via ref
+         * @param pages - sidebar pages
+         * @param dirName - root path of sidebar
+         */
+        function addSidebarDataToFrontmatter(pages, dirName) {
+            pages.forEach(page => {
+                config.setRef(String(page.fullPath), ['sidebarData', '$ref'], path.posix.join(dirName, filename, '#', 'pages'));
+            });
+        }
+        const createNavigationRefs = (rootDir, currPage, prevPage, nextPage) => {
+            if (prevPage) {
+                config.setRef(currPage, ['navigation', 'prev', 'title', '$ref'], `${prevPage}#/title`);
+                config.setRef(currPage, ['navigation', 'prev', 'route', '$ref'], `${prevPage}#/route`);
+                const parentPath = path.posix.dirname(prevPage);
+                if (parentPath !== rootDir) {
+                    config.setRef(currPage, ['navigation', 'prev', 'group', '$ref'], `${parentPath}#/sidebar/groupLabel`);
+                }
+            }
+            if (nextPage) {
+                config.setRef(currPage, ['navigation', 'next', 'title', '$ref'], `${nextPage}#/title`);
+                config.setRef(currPage, ['navigation', 'next', 'route', '$ref'], `${nextPage}#/route`);
+                const parentPath = path.posix.dirname(nextPage);
+                if (parentPath !== rootDir) {
+                    config.setRef(currPage, ['navigation', 'next', 'group', '$ref'], `${parentPath}#/sidebar/groupLabel`);
+                }
+            }
+        };
+        function addNavigationToFrontmatter(pages, rootDir) {
+            const getRelativeDataNode = (node, position) => {
+                let targetNode = node;
+                if (isGroupNode(node)) {
+                    targetNode = node.childNodes[position === 'previous' ? node.childNodes.length - 1 : 0];
+                }
+                return isGroupNode(targetNode) ? getRelativeDataNode(targetNode, position) : targetNode;
+            };
+            const isLastPage = page => {
+                const lastPage = getRelativeDataNode(pages, 'previous');
+                return page === lastPage;
+            };
+            let prevParentPage = [];
+            let nextParentPage = [];
+            function recursiveAddNavigation(pages) {
+                let nextPage, prevPage;
+                pages.forEach((page, pageIndex) => {
+                    if (isLastPage(page)) {
+                        nextPage = undefined;
+                    }
+                    else if (pageIndex === pages.length - 1) {
+                        nextPage = nextParentPage.pop();
+                    }
+                    else {
+                        nextPage = getRelativeDataNode(pages[pageIndex + 1], 'next');
+                    }
+                    if (pageIndex === 0) {
+                        prevPage = prevParentPage.pop();
+                    }
+                    else {
+                        prevPage = getRelativeDataNode(pages[pageIndex - 1], 'previous');
+                    }
+                    if (isDataNode(page)) {
+                        createNavigationRefs(rootDir, page.fullPath, prevPage?.fullPath, nextPage?.fullPath);
+                    }
+                    else {
+                        if (nextPage) {
+                            nextParentPage.push(nextPage);
                         }
-                    case 39:
-                        _ctx.prev = 39;
-                        if (!_didIteratorError) {
-                            _ctx.next = 42;
-                            break;
+                        if (prevPage) {
+                            prevParentPage.push(prevPage);
                         }
-                        throw _iteratorError;
-                    case 42:
-                        return _ctx.finish(39);
-                    case 43:
-                        return _ctx.finish(36);
-                    case 44:
-                    case "end":
-                        return _ctx.stop();
-                }
-            }, _callee, null, [
-                [
-                    12,
-                    32,
-                    36,
-                    44
-                ],
-                [
-                    37,
-                    ,
-                    39,
-                    43
-                ]
-            ]);
-        }))();
+                        recursiveAddNavigation(page.childNodes);
+                    }
+                });
+            }
+            recursiveAddNavigation(pages);
+        }
+        const rootUserJourneys = await mutableFilesystem.promises.glob(rootDirGlob, {
+            onlyDirectories: true,
+            extglob: true,
+            cwd: '/'
+        });
+        const removeExcludedPages = page => !(page.sidebar && page.sidebar.exclude);
+        await Promise.all(rootUserJourneys.map(async (rootDir) => {
+            const sidebarFilePath = path.posix.join(String(rootDir), filename);
+            const pages = await createPageList(rootDir);
+            const includedPages = pages.filter(page => removeExcludedPages(page));
+            const groupMap = createGroupMap(includedPages);
+            const sidebarData = linkGroupMap(groupMap, rootDir);
+            if (sidebarData[0] === undefined) {
+                console.warn(`[Mosaic] SidebarPlugin - Unable to create a Sidebar grouping for ${rootDir}`);
+                console.log('[Mosaic] SidebarPlugin - likely you have a directory without an index file');
+                return;
+            }
+            const sortedRootSidebar = sortSidebarData(sidebarData);
+            addNavigationToFrontmatter(sortedRootSidebar, rootDir);
+            if (isGroupNode(sortedRootSidebar[0])) {
+                await mutableFilesystem.promises.writeFile(sidebarFilePath, JSON.stringify({ pages: sortedRootSidebar[0].childNodes }));
+            }
+            else {
+                console.warn(`[Mosaic] SidebarPlugin - Unable to sort Sidebar grouping for ${rootDir}`);
+            }
+            addSidebarDataToFrontmatter(pages, rootDir);
+        }));
     }
 };
 export default SidebarPlugin;
-
 //# sourceMappingURL=SidebarPlugin.js.map