@jpmorganchase/mosaic-plugins 0.1.0-beta.3 → 0.1.0-beta.4

package/src/PagesWithoutFileExtPlugin.ts

@@ -1,38 +0,0 @@
-import type Page from '@jpmorganchase/mosaic-types/dist/Page';
-import type PluginType from '@jpmorganchase/mosaic-types/dist/Plugin';
-import { escapeRegExp } from 'lodash';
-import path from 'path';
-
-/**
- * Plugin that creates aliases without the file extension for every page emitted by the source.
- * This allows pages to be retrieved from the filesystem without specifying `.mdx` (or whatever file extension is specified in `options.stripExt`).
- * The plugin also modifies the `route` to point to the shorter alias. Friendly fullPaths are the shortest possible paths that
- * will point to the page (see `Page` docs)
- */
-const PagesWithoutFileExtPlugin: PluginType<
-  {}
-> = {
-  async $afterSource(pages: Page[], { config, ignorePages, pageExtensions }) {
-    const isNonHiddenPage = createPageTest(ignorePages, pageExtensions);
-    const pageTest = new RegExp(`${pageExtensions.map(escapeRegExp).join('|')}$`);
-
-    for (const page of pages) {
-      if (!isNonHiddenPage(page.fullPath)) {
-        continue;
-      }
-      page.route = page.route.replace(pageTest, '');
-      config.setAliases(page.fullPath, [page.route]);
-    }
-    return pages;
-  }
-};
-
-export default PagesWithoutFileExtPlugin;
-
-function createPageTest(ignorePages, pageExtensions) {
-  const extTest = new RegExp(`${pageExtensions.map(escapeRegExp).join('|')}$`);
-  const ignoreTest = new RegExp(`${ignorePages.map(escapeRegExp).join('|')}$`);
-  return file => {
-    return !ignoreTest.test(file) && extTest.test(file) && !path.basename(file).startsWith('.');
-  };
-}

package/src/ReadingTimePlugin.mjs.ts

@@ -1,32 +0,0 @@
-import type PluginType from '@jpmorganchase/mosaic-types/dist/Plugin';
-import type Page from '@jpmorganchase/mosaic-types/dist/Page';
-import getReadingTime from 'reading-time';
-import { unified } from 'unified';
-import { visit } from 'unist-util-visit';
-import markdown from 'remark-parse';
-
-/**
- * Calculates reading time for pages and adds to frontmatter
- */
-const ReadingTimePlugin: PluginType<{}> = {
-  async $afterSource(pages: Page[]) {
-    const processor = unified().use(markdown);
-    for (const page of pages) {
-      const tree = await processor.parse(page.content);
-      let textContent = '';
-
-      visit(
-        tree,
-        node => node.type === 'text' || node.type === 'code',
-        node => {
-          textContent += node.value;
-        }
-      );
-      page.readingTime = getReadingTime(textContent);
-    }
-
-    return pages;
-  }
-};
-
-export default ReadingTimePlugin;

package/src/SharedConfigPlugin.ts

@@ -1,49 +0,0 @@
-import type PluginType from '@jpmorganchase/mosaic-types/dist/Plugin';
-import flatten from 'lodash/flatten';
-import path from 'path';
-
-/**
- * Plugin that crawls the page hierarchy to find the closest `sharedConfig` from any parent index's page metadata.
- * It then exports a JSON file (name: `options.filename`) into each directory with the merged config for that level
- */
-const SharedConfigPlugin: PluginType<{}, { filename: string }> = {
-  async $beforeSend(
-    mutableFilesystem,
-    { config, serialiser, ignorePages, pageExtensions },
-    options
-  ) {
-    const pagePaths = await mutableFilesystem.promises.glob(
-      createFileGlob('**/index,/index', pageExtensions),
-      {
-        ignore: [options.filename, ...flatten(ignorePages.map(ignore => [ignore, `**/${ignore}`]))],
-        cwd: '/'
-      }
-    );
-
-    for (const pagePath of pagePaths) {
-      const sharedConfigFile = path.join(path.dirname(String(pagePath)), options.filename);
-
-      const page = await serialiser.deserialise(
-        String(pagePath),
-        await mutableFilesystem.promises.readFile(String(pagePath))
-      );
-      if (page.sharedConfig) {
-        config.setRef(sharedConfigFile, ['config', '$ref'], `${String(pagePath)}#/sharedConfig`);
-        await mutableFilesystem.promises.writeFile(sharedConfigFile, '{}');
-      } else {
-        const baseDir = path.resolve(path.dirname(String(pagePath)), '../');
-
-        config.setAliases(path.join(baseDir, options.filename), [sharedConfigFile]);
-      }
-    }
-  }
-};
-
-export default SharedConfigPlugin;
-
-function createFileGlob(url, pageExtensions) {
-  if (pageExtensions.length === 1) {
-    return `${url}${pageExtensions[0]}`;
-  }
-  return `${url}{${pageExtensions.join(',')}}`;
-}

package/src/SidebarPlugin.ts

@@ -1,154 +0,0 @@
-import path from 'path';
-import type PluginType from '@jpmorganchase/mosaic-types/dist/Plugin';
-
-/**
- * Sorts the pages in a folder by priority and then exports a JSON file (name: `options.filename`) with the
- * sidebar tree from that directory downwards and adds sidebar data into frontmatter for each page.
- */
-
-const SidebarPlugin: PluginType<
-  {
-    dirs: string[];
-    refs: { [key: string]: { $$path: (number | string)[]; $$value: string }[] };
-  },
-  { filename: string }
-> = {
-  async $beforeSend(
-    mutableFilesystem,
-    { config, serialiser, ignorePages, pageExtensions },
-    options
-  ) {
-    const dirs = await mutableFilesystem.promises.glob('**', {
-      onlyDirectories: true,
-      cwd: '/'
-    });
-    for (const dirName of dirs) {
-      const sidebarFilePath = path.posix.join(String(dirName), options.filename);
-      const pages = (
-        await Promise.all(
-          ((await mutableFilesystem.promises.glob(
-            createFileGlob(['*', '*/index'], pageExtensions),
-            {
-              onlyFiles: true,
-              cwd: String(dirName),
-              ignore: ignorePages.map(ignore => `**/${ignore}`)
-            }
-          )) as string[]).map(async pagePath => {
-            return await serialiser.deserialise(
-              pagePath,
-              await mutableFilesystem.promises.readFile(pagePath)
-            );
-          })
-        )
-      )
-        .filter(page => filterFn(page))
-        .sort((pageA, pageB) => sortFn(pageA, pageB, dirName));
-
-      for (let i = 0; i < pages.length; i++) {
-        setPageRefs(sidebarFilePath, pages[i], i);
-        setChildPageRefs(pages[i], dirName, i, sidebarFilePath);
-        addSidebarDataToFrontmatter(pages[i], dirName);
-      }
-      await mutableFilesystem.promises.writeFile(sidebarFilePath, '[]');
-    }
-
-    function setPageRefs(sidebarFilePath, page, i) {
-      config.setRef(sidebarFilePath, ['pages', `${i}`, 'id', '$ref'], `${page.fullPath}#/route`);
-      page.sidebar && page.sidebar.label
-        ? config.setRef(
-            sidebarFilePath,
-            ['pages', `${i}`, 'name', '$ref'],
-            `${page.fullPath}#/sidebar/label`
-          )
-        : config.setRef(
-            sidebarFilePath,
-            ['pages', `${i}`, 'name', '$ref'],
-            `${page.fullPath}#/title`
-          );
-      config.setRef(
-        sidebarFilePath,
-        ['pages', `${i}`, 'data', 'link', '$ref'],
-        `${page.fullPath}#/route`
-      );
-    }
-
-    async function setChildPageRefs(page, dirName, i, sidebarFilePath) {
-      if (isSubfolderIndex(page, dirName)) {
-        const childDirName = path.posix.dirname(page.fullPath);
-        const childNodeSidebarPath = path.posix.join(childDirName, options.filename);
-        const childPages = (
-          await Promise.all(
-            ((await mutableFilesystem.promises.glob(
-              createFileGlob(['*', '*/index'], pageExtensions),
-              {
-                onlyFiles: true,
-                cwd: String(childDirName),
-                ignore: ignorePages.map(ignore => `**/${ignore}`)
-              }
-            )) as string[]).map(async pagePath => {
-              return await serialiser.deserialise(
-                pagePath,
-                await mutableFilesystem.promises.readFile(pagePath)
-              );
-            })
-          )
-        ).filter(page => filterFn(page));
-        if (childPages.length > 1) {
-          for (let j = 1; j < childPages.length; j++) {
-            config.setRef(
-              sidebarFilePath,
-              ['pages', `${i}`, 'childNodes', `${j - 1}`, '$ref'],
-              `${childNodeSidebarPath}#/pages/${j}`
-            );
-          }
-        }
-      }
-    }
-
-    function addSidebarDataToFrontmatter(page, dirName) {
-      const dirNameLevels = String(dirName)
-        .split('/')
-        .filter(level => level);
-      const sidebarRootDir =
-        `/` + dirNameLevels.slice(0, dirNameLevels.length < 3 ? dirNameLevels.length : 3).join(`/`);
-      config.setRef(
-        String(page.fullPath),
-        ['sidebarData', '$ref'],
-        path.posix.join(String(sidebarRootDir), options.filename, '#', 'pages')
-      );
-    }
-  }
-};
-export default SidebarPlugin;
-
-function createFileGlob(patterns, pageExtensions) {
-  if (Array.isArray(patterns)) {
-    return patterns.map(pattern => createFileGlob(pattern, pageExtensions));
-  }
-  if (pageExtensions.length === 1) {
-    return `${patterns}${pageExtensions[0]}`;
-  }
-  return `${patterns}{${pageExtensions.join(',')}}`;
-}
-
-function isSubfolderIndex(page, dirName) {
-  return page.fullPath.split('/').length == String(dirName).split('/').length + 2;
-}
-
-function sortFn(pageA, pageB, dirName) {
-  // Always pin /index to the front
-  if (pageA.route === dirName + '/index') {
-    return -1;
-  }
-  if (pageB.route === dirName + '/index') {
-    return 1;
-  }
-  return (
-    (pageB.sidebar && pageB.sidebar.priority ? pageB.sidebar.priority : -1) -
-    (pageA.sidebar && pageA.sidebar.priority ? pageA.sidebar.priority : -1)
-  );
-}
-
-function filterFn(page) {
-  return !(page.sidebar && page.sidebar.exclude);
-}

package/src/SiteMapPlugin.ts

@@ -1,44 +0,0 @@
-import type PluginType from '@jpmorganchase/mosaic-types/dist/Plugin';
-
-const SiteMapPlugin: PluginType<
-  { sitemaps: string[][] },
-  {}
-> = {
-  // Merge together all of the individual sitemaps from each source
-  async afterUpdate(mutableFilesystem, { sharedFilesystem, globalConfig }) {
-    if (!Array.isArray(globalConfig.data.sitemaps)) {
-      return;
-    }
-    await sharedFilesystem.promises.writeFile(
-      '/sitemap.xml',
-      '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n' +
-        globalConfig.data.sitemaps
-          .map(items =>
-            items
-              .map(
-                item =>
-                  `\t<url>\n\t\t<loc>${String(
-                    item
-                  )}</loc>\n\t\t<changefreq>weekly</changefreq>\n\t\t<priority>0.5</priority>\n\t</url>`
-              )
-              .join('\n')
-          )
-          .join('') +
-        '\n</urlset>'
-    );
-  },
-  // Store a sitemap for just this source
-  async $beforeSend(mutableFilesystem, { config, ignorePages }, options) {
-    config.setData({
-      sitemaps: [
-        (await mutableFilesystem.promises.glob('**', {
-          onlyFiles: true,
-          ignore: ignorePages.map(ignore => `**/${ignore}`),
-          cwd: '/'
-        })) as string[]
-      ]
-    });
-  }
-};
-
-export default SiteMapPlugin;

package/src/TableOfContentsPlugin.mjs.ts

@@ -1,52 +0,0 @@
-import type PluginType from '@jpmorganchase/mosaic-types/dist/Plugin';
-import type Page from '@jpmorganchase/mosaic-types/dist/Page';
-import { visit } from 'unist-util-visit';
-import markdown from 'remark-parse';
-import { unified } from 'unified';
-import Slugger from 'github-slugger';
-import { toString } from 'hast-util-to-string';
-
-type TOCItem = { level: number; id: string; text: string };
-
-/**
- * Calculates table of contents from page headings
- */
-const TableOfContentsPlugin: PluginType<{}, { minRank: 2; maxRank: 4 }> = {
-  async $afterSource(pages: Page[], {}, { minRank, maxRank }) {
-    const processor = unified().use(markdown);
-    const slugger = new Slugger();
-    for (const page of pages) {
-      const tree = await processor.parse(page.content);
-      const items: TOCItem[] = [];
-      visit(
-        tree,
-        node => test(node),
-        node => {
-          const text = toString(node).trim();
-          items.push({
-            level: node.depth,
-            id: slugger.slug(text),
-            text: text
-          });
-        }
-      );
-      page.tableOfContents = items;
-    }
-
-    return pages;
-
-    function test(node) {
-      return node.type === 'heading' && isHeadingInRange(node);
-    }
-
-    function isHeadingInRange(node) {
-      const depth = node.depth;
-      if (depth < minRank || depth > maxRank) {
-        return false;
-      }
-      return true;
-    }
-  }
-};
-
-export default TableOfContentsPlugin;

package/src/utils/normaliseRefs.ts

@@ -1,85 +0,0 @@
-import path from 'path';
-
-import glob from 'fast-glob';
-import set from 'lodash/set';
-
-function createFileGlob(url, pageExtensions) {
-  if (pageExtensions.length === 1) {
-    return `${url}${pageExtensions[0]}`;
-  }
-  return `${url}{${pageExtensions.join(',')}}`;
-}
-
-export default async function normaliseRefs(filepath, refs, filesystem, pageExtensions, ignorePages) {
-  const configWithoutGlobs = {};
-
-  for (let i = 0; i < refs.length; i++) {
-    const ref = refs[i];
-    const [url, fragment = ''] = ref.$$value.split('#');
-
-    if (!url) {
-      continue;
-    }
-
-    const fullUrl = path.resolve(path.dirname(filepath), url);
-
-    if (!glob.isDynamicPattern(url)) {
-      if (!(await filesystem.promises.exists(fullUrl))) {
-        throw new Error(
-          `A \`$ref\` for '${filepath}' pointed to page '${fullUrl}' - which could not be found.`
-        );
-      }
-      const refRealPath = await filesystem.promises.realpath(
-        fullUrl
-        //path.resolve(path.dirname(filepath), url)
-      );
-      const stat = await filesystem.promises.stat(refRealPath);
-      // Turn directory refs into full index paths
-      // TODO: But DO we want to do this?
-      if (stat.isDirectory()) {
-        // && !/\/index(\.\w{1,4})?$/.test(url)) {
-        set(configWithoutGlobs, ref.$$path.slice(0, -1), {
-          $ref: `${await filesystem.promises.realpath(path.join(refRealPath, 'index'))}#${fragment}`
-        });
-      } else {
-        set(configWithoutGlobs, ref.$$path.slice(0, -1), {
-          $ref: `${refRealPath}#${fragment}`
-        });
-      }
-      continue;
-    }
-
-    try {
-      let globResolvedRefs =
-        // If the pattern doesn't have an explicit file extension - then we'll make it just return pages
-        await filesystem.promises.glob(
-          !/\/[^/]+\.\w{2,4}$/.test(url) ? createFileGlob(url, pageExtensions) : url,
-          {
-            ignore: [filepath, ...ignorePages.map(ignore => `**/${ignore}`)],
-            cwd: path.dirname(filepath),
-            absolute: true
-          }
-        );
-
-      // Use a set so we de-dupe any symlinks that point to the same page
-      const resolvedRefs = new Set();
-
-      for (const value of globResolvedRefs) {
-        const refRealPath = await filesystem.promises.realpath(path.resolve(filepath, value));
-        if (refRealPath !== (await filesystem.promises.realpath(filepath))) {
-          resolvedRefs.add(`${refRealPath}#${fragment}`);
-        }
-      }
-
-      set(
-        configWithoutGlobs,
-        ref.$$path.slice(0, -1),
-        Array.from(resolvedRefs).map($ref => ({ $ref }))
-      );
-    } catch (e) {
-      throw e;
-    }
-  }
-
-  return configWithoutGlobs;
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "allowJs": true,
-    "target": "es2015",
-    "esModuleInterop": true,
-    "moduleResolution": "NodeNext",
-    "outDir": "dist",
-    "skipLibCheck": true,
-    "sourceMap": true,
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "exclude": [
-    "node_modules",
-    "src/**/__tests__/**/*",
-    "src/__tests__/**/*",
-    "src/**/*.mjs.*",
-    "**/dist/**/*"
-  ]
-}