@kenjura/ursa 0.5.0

package/src/helper/automenu.js

@@ -0,0 +1,120 @@
+import dirTree from "directory-tree";
+import { extname, basename } from "path";
+
+export async function getAutomenu(source) {
+  const tree = dirTree(source);
+  const menuItems = [];
+
+  /** order of menu items:
+   *  - Home
+   *  - Top-level folders A-Z
+   *  - Top-level files A-Z
+   **/
+
+  menuItems.push({
+    path: "/",
+    name: "Home",
+    type: "file",
+  });
+
+  const topLevelItems = tree.children.sort(childSorter);
+  const topLevelHtml = topLevelItems
+    .map((item) => renderMenuItem({ ...item, source }))
+    .join("");
+
+  return `<ul>${topLevelHtml}</ul>`;
+}
+
+function renderMenuItem({ path, name, children, source }) {
+  const ext = extname(path);
+  const href = path.replace(source, "").replace(ext, "");
+  const label = basename(path, ext);
+  //   const childMenuItems = Array.isArray(children)
+  //     ? children
+  //         .map((child) => renderMenuItem({ ...child, source }))
+  //         .sort(menuItemSorter)
+  //     : null;
+  const html = `
+<li data-has-children="${!!children}">
+  <a href="/${href}">${label}</a>
+  ${
+    children
+      ? `<ul>
+    ${children
+      .sort(childSorter)
+      .map((child) => renderMenuItem({ ...child, source }))
+      .join("")}
+  </ul>`
+      : ""
+  }
+</li>`;
+  return html;
+
+  return {
+    href,
+    label,
+    childMenuItems,
+  };
+
+  /**
+   * example output:
+   * {
+   *   href:'Foo/Bar',
+   *   label:'Bar',
+   *   childMenuItems: [thisObject]
+   * }
+   */
+}
+
+function childSorter(a, b) {
+  if (a.children && !b.children) return -1;
+  if (b.children && !a.children) return 1;
+  if (a.name > b.name) return 1;
+  if (a.name < b.name) return -1;
+  return 0;
+}
+
+function menuItemSorter(a, b) {
+  if (a.childMenuItems && !b.childMenuItems) return -1;
+  if (b.childMenuItems && !a.childMenuItems) return 1;
+  if (a.label > b.label) return 1;
+  if (a.label < b.label) return -1;
+  return 0;
+}
+
+export async function OLDgetAutomenu(source) {
+  const trimmedFilenames = allSourceFilenames.map((filename) => ({
+    filename: filename.replace(source, ""),
+    depth: filename.split("").filter((char) => char === "/").length,
+  }));
+  const sortedFilenames = [...trimmedFilenames].sort((a, b) => {
+    if (a.depth > b.depth) return 1;
+    if (a.depth < b.depth) return -1;
+    if (a.filename > b.filename) return 1;
+    if (a.filename < b.filename) return -1;
+    return 0;
+  });
+  const menuItems = sortedFilenames
+    .filter((filename) => filename.indexOf(".md") > -1)
+    .filter((filename) => filename.indexOf("menu.") === -1)
+    .map((filename) => {
+      const depthPrefix = filename
+        .split("")
+        .filter((char) => char === "/")
+        .map((char) => "  ")
+        .join("");
+      const ext = extname(filename);
+      const articleName = basename(filename, ext);
+      const link = filename.replace(ext, "");
+      const menuItem = `${depthPrefix}+ [${articleName}](${link})`;
+      return menuItem;
+    });
+  return menuItems.join("\n");
+
+  /*
++ [Home](/5e)
++ [Classes](/5e/Classes)
+  + [Artificer](/5e/Classes/Artificer)
+  + [Elementalist](/5e/Classes/Elementalist)
+  */
+}

package/src/helper/fileRenderer.js

@@ -0,0 +1,18 @@
+
+import { markdownToHtml } from "./markdownHelper.cjs";
+import { wikiToHtml } from "./wikitextHelper.js";
+
+const DEFAULT_WIKITEXT_ARGS = { db: "noDB", noSection: true, noTOC: true };
+
+export function renderFile({ fileContents, type, dirname, basename }) {
+  switch (type) {
+    case ".md":
+      return markdownToHtml(fileContents);
+    case ".txt":
+      return wikiToHtml({
+        wikitext: fileContents,
+        articleName: basename,
+        args: { ...DEFAULT_WIKITEXT_ARGS, db: dirname },
+      })?.html;
+  }
+}

package/src/helper/filterAsync.js

@@ -0,0 +1,5 @@
+export async function filterAsync(arr, predicate) {
+  const results = await Promise.all(arr.map(predicate));
+
+  return arr.filter((_v, index) => results[index]);
+}

package/src/helper/isDirectory.js

@@ -0,0 +1,10 @@
+import { lstat } from "fs/promises";
+
+export async function isDirectory(pathname) {
+  const stats = await lstat(pathname);
+  try {
+    return stats.isDirectory();
+  } catch (err) {
+    console.error(`isDirectory > failed to stat ${pathname}:`, err);
+  }
+}

package/src/helper/markdownHelper.cjs

@@ -0,0 +1,36 @@
+const markdown = require("markdown-it")({ html: true });
+
+markdown.use(require("markdown-it-container"), "aside", getAside());
+markdown.use(require("markdown-it-deflist"));
+markdown.use(require("markdown-it-sup"));
+markdown.use(require("markdown-it-front-matter"), handleFrontMatter);
+
+module.exports = { markdownToHtml };
+
+function markdownToHtml(md) {
+  return markdown.render(md);
+}
+
+function getAside() {
+  return {
+    validate: function (params) {
+      return true;
+      return params.trim().match(/^aside\s+(.*)$/);
+    },
+
+    render: function (tokens, idx) {
+      var m = tokens[idx].info.trim().match(/^aside\s+(.*)$/);
+
+      if (tokens[idx].nesting === 1) {
+        // opening tag
+        // return '<aside><summary>ASIDE' + m[1] + '</summary>\n';
+        return "<aside>\n";
+      } else {
+        // closing tag
+        return "</aside>\n";
+      }
+    },
+  };
+}
+
+function handleFrontMatter(frontMatter) {}

package/src/helper/metadataExtractor.js

@@ -0,0 +1,30 @@
+import { parse } from "yaml";
+
+export function extractMetadata(rawBody) {
+  const frontMatter = matchFrontMatter(rawBody);
+  if (frontMatter === null) return null;
+
+  const parsedYml = parse(frontMatter);
+  return parsedYml;
+}
+
+export function extractRawMetadata(rawBody) {
+  const frontMatter = matchAllFrontMatter(rawBody);
+  if (frontMatter === null) return null;
+
+  return frontMatter;
+}
+
+function matchFrontMatter(str) {
+  const match = str.match(/---(.*?)---/s);
+  if (Array.isArray(match) && match.length > 1) {
+    return match[1];
+  } else return null;
+}
+
+function matchAllFrontMatter(str) {
+  const match = str.match(/---(.*?)---\n+/s);
+  if (Array.isArray(match) && match.length > 0) {
+    return match[0];
+  } else return null;
+}

package/src/helper/objToXml.js

@@ -0,0 +1,20 @@
+export function objToXml(obj) {
+  var xml = "";
+  for (var prop in obj) {
+    xml += obj[prop] instanceof Array ? "" : "<" + prop + ">";
+    if (obj[prop] instanceof Array) {
+      for (var array in obj[prop]) {
+        xml += "<" + prop + ">";
+        xml += objToXml(new Object(obj[prop][array]));
+        xml += "</" + prop + ">";
+      }
+    } else if (typeof obj[prop] == "object") {
+      xml += objToXml(new Object(obj[prop]));
+    } else {
+      xml += obj[prop];
+    }
+    xml += obj[prop] instanceof Array ? "" : "</" + prop + ">";
+  }
+  var xml = xml.replace(/<\/?[0-9]{1,}>/g, "");
+  return xml;
+}

package/src/helper/pathExtReader.js

@@ -0,0 +1,12 @@
+import { extname } from "path";
+
+export function hasExt(pathname) {
+  const ext = extname(pathname);
+  console.log({
+    pathname,
+    ext,
+    result: ext === "" || ext === "." ? false : true,
+  });
+  if (ext === "" || ext === ".") return false;
+  else return true;
+}