docs(lib): add lib v1.0.0

Author: amen-souissi

docs/src/lib/docs/findRouteByPath.js

@@ -0,0 +1,13 @@
+import { removeFromLast } from './utils';
+// @ts-ignore
+export function findRouteByPath(path, routes) {
+  // eslint-disable-next-line
+  for (const route of routes) {
+    if (route.path && removeFromLast(route.path, '.') === path) {
+      return route;
+    }
+
+    const childPath = route.routes && findRouteByPath(path, route.routes);
+    if (childPath) return childPath;
+  }
+}

docs/src/lib/docs/md-loader.js

@@ -0,0 +1,22 @@
+const fm = require('gray-matter')
+
+// makes mdx in next.js suck less by injecting necessary exports so that
+// the docs are still readable on github
+// (Shamelessly stolen from Expo.io docs)
+// @see https://github.com/expo/expo/blob/master/docs/common/md-loader.js
+module.exports = async function (src) {
+  const callback = this.async()
+  const { content, data } = fm(src)
+  const layout = data.layout || 'Docs'
+  const code =
+    `import { Layout${layout} } from 'components/Layout${layout}';
+export const meta = ${JSON.stringify(data)};
+export default ({ children, ...props }) => (
+  <Layout${layout} meta={meta} {...props}>{children}</Layout${layout}>
+);
+
+
+` + content
+
+  return callback(null, code)
+}

docs/src/lib/docs/remark-paragraph-alerts.js

@@ -0,0 +1,45 @@
+const is = require('unist-util-is');
+const visit = require('unist-util-visit');
+
+const sigils = {
+  '=>': 'success',
+  '->': 'info',
+  '~>': 'warning',
+  '!>': 'danger',
+};
+
+module.exports = function paragraphCustomAlertsPlugin() {
+  return function transformer(tree) {
+    visit(tree, 'paragraph', (pNode, _, parent) => {
+      visit(pNode, 'text', textNode => {
+        Object.keys(sigils).forEach(symbol => {
+          if (textNode.value.startsWith(`${symbol} `)) {
+            // Remove the literal sigil symbol from string contents
+            textNode.value = textNode.value.replace(`${symbol} `, '');
+
+            // Wrap matched nodes with <div> (containing proper attributes)
+            parent.children = parent.children.map(node => {
+              return is(pNode, node)
+                ? {
+                    type: 'wrapper',
+                    children: [node],
+                    data: {
+                      hName: 'div',
+                      hProperties: {
+                        className: [
+                          'alert',
+                          `alert-${sigils[symbol]}`,
+                          'g-type-body',
+                        ],
+                        role: 'alert',
+                      },
+                    },
+                  }
+                : node;
+            });
+          }
+        });
+      });
+    });
+  };
+};

docs/src/lib/docs/utils.js

@@ -0,0 +1,4 @@
+export function removeFromLast(path, key) {
+  const i = path.lastIndexOf(key)
+  return i === -1 ? path : path.substring(0, i)
+}

docs/src/lib/fs-utils.js

@@ -0,0 +1,4 @@
+import fs from 'fs';
+import { promisify } from 'util';
+export const readFile = promisify(fs.readFile);
+export const writeFile = promisify(fs.writeFile);

docs/src/lib/get-route-context.js

@@ -0,0 +1,51 @@
+/**
+ * Returns the siblings of a specific route (that is the previous and next routes).
+ */
+export function getRouteContext(_route, routes, ctx = {}) {
+  if (!_route) {
+    return ctx;
+  }
+
+  const {
+    path
+  } = _route;
+  const {
+    parent
+  } = ctx;
+
+  for (let i = 0; i < routes.length; i += 1) {
+    const route = routes[i];
+
+    if (route.routes) {
+      ctx.parent = route;
+      ctx = getRouteContext(_route, route.routes, ctx); // If the active route and the next route was found in nested routes, return it
+
+      if (ctx.nextRoute) return ctx;
+    }
+
+    if (!route) continue;
+    if (!route.path) continue;
+
+    if (ctx.route) {
+      ctx.nextRoute = parent && i === 0 ? { ...route,
+        title: `${parent.title}: ${route.title}`
+      } : route;
+      return ctx;
+    }
+
+    if (route && route.path === path) {
+      ctx.route = { ..._route,
+        title: parent && !parent.heading ? `${parent.title}: ${_route.title}` : _route.title
+      }; // Continue the loop until we know the next route
+
+      continue;
+    }
+
+    ctx.prevRoute = parent && !parent.heading && !routes[i + 1]?.path ? { ...route,
+      title: `${parent.title}: ${route.title}`
+    } : route;
+  } // The loop ended and the previous route was found, or nothing
+
+
+  return ctx;
+}