@d10f/asciidoc-astro-loader 0.0.1

package/dist/index.cjs

@@ -0,0 +1,708 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  asciidocLoader: () => asciidocLoader
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/loader.ts
+var import_node_fs4 = require("fs");
+var import_node_process = require("process");
+
+// src/lib/asciidoc/AsciidocDocument.ts
+var import_asciidoctor = __toESM(require("asciidoctor"), 1);
+
+// src/lib/utils.ts
+function slugify(text) {
+  return text.trim().normalize().toLowerCase().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+function escapeRegexCharacters(str) {
+  const re = /[-\\^$*+?.()|\[\]{}]/g;
+  return str.replace(re, "\\$&");
+}
+function splitFilenameComponents(filename) {
+  const match = filename.match(/^(?<path>.*\/)*(?<name>[^\.]+)\.(?<ext>.*)$/);
+  return {
+    filepath: match?.groups?.path ?? null,
+    filename: match?.groups?.name ?? null,
+    extension: match?.groups?.ext ?? null
+  };
+}
+
+// src/lib/asciidoc/BaseConverter.ts
+var BaseConverter = class {
+  constructor(defaultConverter) {
+    this.defaultConverter = defaultConverter;
+    this.customConverters = /* @__PURE__ */ new Map();
+    this.templateEngine = void 0;
+  }
+  customConverters;
+  templateEngine;
+  /**
+   * Registers a new custom converter to act upon a specific block type.
+   */
+  register(converter) {
+    const context = converter.nodeContext;
+    this.customConverters.set(context, converter);
+  }
+  registerTemplateEngine(templateEngine) {
+    this.templateEngine = templateEngine;
+  }
+  /**
+   * Converts the node to an HTML string. If the node's context matches one of
+   * the registered converters, it will use that converter.
+   */
+  convert(node) {
+    const context = node.getNodeName();
+    const converter = this.customConverters.get(context);
+    if (converter) {
+      const output = converter.convert(node, this.templateEngine);
+      if (output) return output;
+    }
+    if (this.templateEngine) {
+      const output = this.templateEngine.convert(node);
+      if (output) return output;
+    }
+    return this.defaultConverter.convert(node);
+  }
+};
+
+// src/lib/asciidoc/TemplateEngineRegistry.ts
+var import_node_fs = require("fs");
+var TemplateEngineRegistry = class _TemplateEngineRegistry {
+  /**
+   * A list of supported templating engines, their associated extensions
+   * and associatied template files to render.
+   */
+  static modules = [];
+  /**
+   * A list of all the node existing contexts an Asciidoc node can have.
+   */
+  static nodeContexts = [
+    "admonition",
+    "audio",
+    "colist",
+    "dlist",
+    "document",
+    "embedded",
+    "example",
+    "floating-title",
+    "image",
+    "inline_anchor",
+    "inline_break",
+    "inline_button",
+    "inline_callout",
+    "inline_footnote",
+    "inline_image",
+    "inline_indexterm",
+    "inline_kbd",
+    "inline_menu",
+    "inline_quoted",
+    "listing",
+    "literal",
+    "olist",
+    "open",
+    "outline",
+    "page_break",
+    "paragraph",
+    "preamble",
+    "quote",
+    "section",
+    "sidebar",
+    "stem",
+    "table",
+    "thematic_break",
+    "toc",
+    "ulist",
+    "verse",
+    "video"
+  ];
+  constructor(templateEngines, options) {
+    for (let i = 0; i < templateEngines.length; i++) {
+      const current = templateEngines[i];
+      for (let j = 0; j < i; j++) {
+        const previous = templateEngines[j];
+        if (current.name === previous.name) {
+          throw new Error(
+            `Engine named "${current.name}" is already registered.`
+          );
+        }
+        current.extensions.forEach((currentExt) => {
+          if (previous.extensions.includes(currentExt)) {
+            throw new Error(
+              `Extension "${currentExt}" is already handled by engine "${previous.name}".`
+            );
+          }
+        });
+      }
+      _TemplateEngineRegistry.modules.push(templateEngines[i]);
+    }
+    this.loadTemplates(options);
+  }
+  /**
+   * Asynchronously loads the necessary third party modules.
+   */
+  async loadEngines() {
+    _TemplateEngineRegistry.modules.forEach(async (m) => {
+      if (m.canLoad) {
+        await m.load();
+      }
+    });
+  }
+  /**
+   * Returns the module with the given name.
+   */
+  getEngineByName(name) {
+    return _TemplateEngineRegistry.modules.find((m) => m.name === name);
+  }
+  /**
+   * Returns the module that supports the given extension.
+   */
+  getEngineByExtension(ext) {
+    return _TemplateEngineRegistry.modules.find(
+      (m) => m.extensions.includes(ext)
+    );
+  }
+  /**
+   * Converts the provided node using one of the registered template
+   * engine modules. For more granular control, gain access to the
+   * engine itself with _getEngineByName_ or _getEngineByExtension_
+   * and use one of its render methods directly.
+   */
+  convert(node, options = {}) {
+    const context = node.getNodeName();
+    return _TemplateEngineRegistry.modules.find((m) => m.hasContext(context))?.renderNode(node, options);
+  }
+  /**
+   * Scans the templates directory and creates an index of all templates
+   * based on supported block names and extensions.
+   *
+   * @see https://docs.asciidoctor.org/asciidoctor.js/latest/extend/converter/template-converter/#naming-convention
+   */
+  loadTemplates({ rootDir, recursive }) {
+    (0, import_node_fs.readdirSync)(rootDir, {
+      encoding: "utf8",
+      recursive
+    }).forEach((template) => {
+      const { filename, extension } = splitFilenameComponents(
+        template
+      );
+      if (!filename || !extension) return false;
+      if (!_TemplateEngineRegistry.nodeContexts.includes(filename))
+        return false;
+      const engineModule = _TemplateEngineRegistry.modules.find((m) => {
+        return m.supportsExt(extension);
+      });
+      if (engineModule) {
+        engineModule.addContext(filename, `${rootDir}/${template}`);
+      }
+    });
+  }
+};
+
+// src/lib/asciidoc/AsciidocDocument.ts
+var AsciidocDocument = class {
+  document;
+  baseConverter;
+  constructor(filepath) {
+    const asciidoc = (0, import_asciidoctor.default)();
+    this.baseConverter = new BaseConverter(
+      asciidoc.Html5Converter.create()
+    );
+    asciidoc.ConverterFactory.register(this.baseConverter, ["html5"]);
+    this.document = asciidoc.loadFile(filepath);
+  }
+  get documentTitle() {
+    return this.document.getDocumentTitle({
+      partition: true
+    });
+  }
+  get title() {
+    return this.documentTitle.getMain();
+  }
+  get subtitle() {
+    return this.documentTitle.getSubtitle();
+  }
+  get slug() {
+    return slugify(this.title);
+  }
+  get preamble() {
+    const [documentBlock] = this.document.getBlocks();
+    const [preambleBlock] = documentBlock?.getBlocks();
+    if (preambleBlock) return preambleBlock.getSourceLines()[0];
+  }
+  get version() {
+    return this.document.getRevisionNumber();
+  }
+  get createdAt() {
+    return this.document.getRevisionDate();
+  }
+  get keywords() {
+    return this.document.getAttribute("keywords");
+  }
+  get languages() {
+    return this.document.findBy({ context: "listing", style: "source" }).reduce((acc, cur) => {
+      const lang = cur.getAttribute("language");
+      if (!lang) return acc;
+      return acc.add(lang);
+    }, /* @__PURE__ */ new Set());
+  }
+  convert(converters = [], templateEngine) {
+    converters.forEach((converter) => {
+      this.baseConverter.register(converter);
+    });
+    if (templateEngine) {
+      this.baseConverter.registerTemplateEngine(templateEngine);
+    }
+    return this.document.getContent();
+  }
+};
+
+// src/schemas/index.ts
+var import_zod3 = require("zod");
+
+// src/schemas/document.ts
+var import_node_path = require("path");
+var import_zod = require("zod");
+var documentOptionsSchema = import_zod.z.looseObject({
+  mode: import_zod.z.union([import_zod.z.literal("safe"), import_zod.z.literal("unsafe")]).default("safe"),
+  template: import_zod.z.string().default("").transform((val) => (0, import_node_path.resolve)(process.cwd(), val)),
+  recursive: import_zod.z.boolean().default(false)
+}).default({
+  mode: "safe",
+  template: "",
+  recursive: false
+});
+
+// src/schemas/shiki.ts
+var import_zod2 = require("zod");
+var shikiOptionsSchema = import_zod2.z.object({
+  theme: import_zod2.z.union([
+    import_zod2.z.string(),
+    import_zod2.z.object({
+      light: import_zod2.z.string(),
+      dark: import_zod2.z.string()
+    }).catchall(import_zod2.z.string())
+  ]).transform(transformThemeProp).default({
+    light: "catppuccin-latte",
+    dark: "catppuccin-macchiato"
+  }),
+  defaultColor: import_zod2.z.string().default("light-dark()"),
+  cssVariablePrefix: import_zod2.z.string().default("--shiki-"),
+  mergeWhitespaces: import_zod2.z.union([import_zod2.z.boolean(), import_zod2.z.literal("never")]).default(true),
+  tabindex: import_zod2.z.union([import_zod2.z.number(), import_zod2.z.string(), import_zod2.z.literal(false)]).default(false)
+}).transform(({ theme, ...rest }) => ({
+  themes: theme,
+  ...rest
+})).default({
+  mergeWhitespaces: true,
+  cssVariablePrefix: "--shiki-",
+  defaultColor: "light-dark()",
+  tabindex: false,
+  theme: {
+    light: "catppuccin-latte",
+    dark: "catppuccin-macchiato"
+  }
+});
+function transformThemeProp(value) {
+  return typeof value === "string" ? { light: value, dark: value } : value;
+}
+
+// src/schemas/index.ts
+var preambleOptionsSchema = import_zod3.z.object({
+  tableOfContents: import_zod3.z.boolean().default(true),
+  maxLevel: import_zod3.z.number().max(6).min(1).default(3),
+  position: import_zod3.z.union([import_zod3.z.literal("before"), import_zod3.z.literal("after")]).default("after")
+}).default({
+  tableOfContents: true,
+  maxLevel: 3,
+  position: "after"
+});
+var loaderOptionsSchema = import_zod3.z.object({
+  base: import_zod3.z.string(),
+  document: documentOptionsSchema,
+  syntaxHighlighting: shikiOptionsSchema,
+  preamble: preambleOptionsSchema
+});
+
+// src/lib/shiki/Highlighter.ts
+var import_shiki2 = require("shiki");
+async function createHighlighter(documents, themes) {
+  const langs = documents.reduce((acc, cur) => {
+    cur.languages.forEach((lang) => {
+      acc.add(lang);
+    });
+    return acc;
+  }, /* @__PURE__ */ new Set());
+  const highlighter = await (0, import_shiki2.createHighlighterCore)({
+    themes: Object.values(themes).map((theme) => {
+      return import(`@shikijs/themes/${theme}`);
+    }),
+    langs: Array.from(langs).map((lang) => {
+      return import(`@shikijs/langs/${lang}`);
+    }),
+    engine: (0, import_shiki2.createJavaScriptRegexEngine)()
+  });
+  return Object.freeze(highlighter);
+}
+
+// src/lib/asciidoc/converters/sourceCodeConverter.ts
+var import_transformers = require("@shikijs/transformers");
+var import_node_path2 = require("path");
+
+// src/lib/shiki/transformers/transformAsciidocCallout.ts
+function transformAsciidocCallout({
+  node,
+  cssClasses = "pointer-events-none select-none ml-2"
+}) {
+  const lineComments = ["//", "#", ";;"];
+  const customLineComment = node.getAttribute("line-comment");
+  if (customLineComment) {
+    lineComments.push(escapeRegexCharacters(customLineComment));
+  }
+  const calloutReList = [
+    // Handles C-style and similar comments like Perl, Python...
+    new RegExp(`(?:${lineComments.join("|")})((?:\\s+<(\\d+)>)+)`),
+    // Handles XML comments
+    new RegExp(/((?:\s*<!--(\d+)-->)+)/)
+  ];
+  const linesWithCallout = {};
+  return {
+    preprocess(code) {
+      return code.split("\n").map((line, idx) => {
+        for (const re of calloutReList) {
+          const match = line.match(re);
+          if (!match) continue;
+          const callouts = match[0].trim().replaceAll(/(?:<!--|-->|[<>])/g, "").split(" ");
+          linesWithCallout[idx + 1] = callouts;
+          return line.replace(re, "");
+        }
+        return line;
+      }).join("\n");
+    },
+    line(hast, line) {
+      const callouts = linesWithCallout[line];
+      if (!callouts) return;
+      callouts.forEach((calloutId) => {
+        hast.properties[`data-callout-${calloutId}`] = "";
+        hast.children.push({
+          type: "element",
+          tagName: "i",
+          properties: {
+            class: `conum ${cssClasses}`,
+            "data-value": calloutId
+          },
+          children: [
+            {
+              type: "element",
+              tagName: "b",
+              properties: {},
+              children: [
+                {
+                  type: "text",
+                  value: calloutId
+                }
+              ]
+            }
+          ]
+        });
+      });
+    }
+  };
+}
+
+// src/lib/shiki/transformers/transformConsoleCodeBlock.ts
+function transformConsoleCodeBlock(options = {
+  cssClasses: "pointer-events-none select-none mr-2 opacity-50"
+}) {
+  const unselectablePrompt = `<span $1 class="${options.cssClasses}">$</span>`;
+  const linePrefix = '<span class="line[^>]+?>';
+  const splitPrompt = new RegExp(
+    `(?<=${linePrefix})(?:<span (style="[^"]*?")>\\s*?\\$\\s+?([^<]))`
+  );
+  const trimWhitespace = new RegExp(
+    `(?<=${linePrefix})(?:<span (style="[^"]*?")>\\s*?\\$\\s*?<\\/span>(?:<span>\\s+<\\/span>)?)`
+  );
+  const trimWhitespaceAhead = new RegExp(
+    `(?<=${linePrefix}<span [^>]+?>\\$<\\/span>)(<span style="[^"]+?">)\\s+?`
+  );
+  return {
+    postprocess: (html, { lang }) => {
+      if (lang === "console") {
+        return html.split("\n").map((line) => {
+          return line.replace(
+            splitPrompt,
+            unselectablePrompt + "<span $1>$2"
+          ).replace(trimWhitespace, unselectablePrompt).replace(trimWhitespaceAhead, "$1");
+        }).join("\n");
+      }
+    }
+  };
+}
+
+// src/lib/asciidoc/converters/sourceCodeConverter.ts
+var sourceCodeConverter = ({ nodeContext, transformers, template }) => {
+  return (options, highlighter) => {
+    return {
+      nodeContext: nodeContext ?? "listing",
+      convert(node, templateEngine) {
+        const input = node.getSourceLines().join("\n");
+        const lang = node.getAttribute("language");
+        const output = highlighter.codeToHtml(input, {
+          ...options.syntaxHighlighting,
+          lang,
+          transformers: [
+            ...transformers ?? [],
+            (0, import_transformers.transformerNotationDiff)(),
+            (0, import_transformers.transformerNotationHighlight)(),
+            (0, import_transformers.transformerNotationFocus)(),
+            transformAsciidocCallout({ node }),
+            transformConsoleCodeBlock()
+          ]
+        });
+        if (templateEngine && template) {
+          const { extension } = splitFilenameComponents(template);
+          const engine = templateEngine.getEngineByExtension(
+            extension || ""
+          );
+          if (engine) {
+            const templateFile = (0, import_node_path2.resolve)(process.cwd(), template);
+            if (engine.canRenderFile) {
+              return engine.renderFile(templateFile, {
+                content: output,
+                lang
+              });
+            }
+          }
+        }
+        return output;
+      }
+    };
+  };
+};
+
+// src/lib/asciidoc/templates/engines/Handlebars.ts
+var import_node_fs2 = require("fs");
+
+// src/lib/asciidoc/templates/engines/Base.ts
+var AbstractEngine = class {
+  constructor(_name, _extensions) {
+    this._name = _name;
+    this._extensions = _extensions;
+    this.templateList = /* @__PURE__ */ new Map();
+  }
+  templateList;
+  /**
+   * Returns the given name to this template engine.
+   */
+  get name() {
+    return this._name;
+  }
+  /**
+   * Returns the list of extensions this template engine supports.
+   */
+  get extensions() {
+    return this._extensions;
+  }
+  /**
+   * Accessor method to check if instance implements the
+   * TemplateModule interface.
+   */
+  get canLoad() {
+    return "load" in this && typeof this.load === "function";
+  }
+  /**
+   * Accessor method to check if instance implements the
+   * AsciidocTemplate interface.
+   */
+  get canRenderNode() {
+    return "renderNode" in this && typeof this.renderNode === "function";
+  }
+  /**
+   * Accessor method to check if instance implements the
+   * FilesystemTemplate interface.
+   */
+  get canRenderFile() {
+    return "renderFile" in this && typeof this.renderFile === "function";
+  }
+  /**
+   * Accessor method to check if instance implements the
+   * RawTemplate interface.
+   */
+  get canRenderString() {
+    return "renderString" in this && typeof this.renderString === "function";
+  }
+  /**
+   * Appends a new context that this template engine will act upon.
+   */
+  addContext(context, filepath) {
+    this.templateList.set(context, filepath);
+  }
+  /**
+   * Verifies whether the specified context is being tracked or not.
+   */
+  hasContext(context) {
+    return typeof context === "string" ? this.templateList.has(context) : this.templateList.has(context.getNodeName());
+  }
+  /**
+   * Verifies if the specified file extension is supported
+   * by this template engine.
+   */
+  supportsExt(extension) {
+    return this.extensions.includes(extension);
+  }
+};
+
+// src/lib/asciidoc/templates/engines/Handlebars.ts
+var HandlebarsEngine = class extends AbstractEngine {
+  render;
+  constructor(name = "handlebars", extensions = ["handlebars", "hbs"]) {
+    super(name, extensions);
+    this.render = null;
+  }
+  async load() {
+    const Handlebars = await import("handlebars");
+    this.render = (input, opts) => {
+      return Handlebars.default.compile(input)(opts);
+    };
+  }
+  renderNode(node, options = {}) {
+    const context = node.getNodeName();
+    return this.renderFile(this.templateList.get(context), options);
+  }
+  renderFile(filepath, options = {}) {
+    const fileContents = (0, import_node_fs2.readFileSync)(filepath, { encoding: "utf8" });
+    return this.renderString(fileContents, options);
+  }
+  renderString(str, options = {}) {
+    if (this.render === null) {
+      throw new Error("This template doesn't have a render method!");
+    }
+    return this.render(str, options);
+  }
+};
+
+// src/lib/asciidoc/templates/engines/Nunjucks.ts
+var import_node_fs3 = require("fs");
+var NunjucksEngine = class extends AbstractEngine {
+  render;
+  constructor(name = "nunjucks", extensions = ["nunjucks", "njk"]) {
+    super(name, extensions);
+    this.render = null;
+  }
+  async load() {
+    const nunjucks = await import("nunjucks");
+    this.render = nunjucks.default.renderString;
+  }
+  renderNode(node, options = {}) {
+    const context = node.getNodeName();
+    return this.renderFile(this.templateList.get(context), options);
+  }
+  renderFile(filepath, options = {}) {
+    const fileContents = (0, import_node_fs3.readFileSync)(filepath, { encoding: "utf8" });
+    return this.renderString(fileContents, options);
+  }
+  renderString(str, options = {}) {
+    if (this.render === null) {
+      throw new Error("This template doesn't have a render method!");
+    }
+    return this.render(str, options);
+  }
+};
+
+// src/loader.ts
+function asciidocLoader(options) {
+  const parsedOpts = loaderOptionsSchema.parse(options);
+  if (parsedOpts.document.converters === void 0) {
+    parsedOpts.document.converters = [
+      sourceCodeConverter({ nodeContext: "listing" })
+    ];
+  }
+  if (parsedOpts.document.templateEngines === void 0) {
+    parsedOpts.document.templateEngines = [
+      new HandlebarsEngine(),
+      new NunjucksEngine()
+    ];
+  }
+  return {
+    name: "asciidoc-loader",
+    async load({ config, parseData, store, logger }) {
+      const root = config.root.pathname;
+      const base = parsedOpts.base.startsWith(".") ? (0, import_node_fs4.realpathSync)(options.base) : root + options.base;
+      const docs = (0, import_node_fs4.readdirSync)(base, "utf8").filter((file) => file.match(/(?:\.a(?:scii)?doc)$/)).map((filename) => new AsciidocDocument(`${base}/${filename}`));
+      if (docs.length === 0) {
+        logger.warn("No documents found for this collection.");
+        return;
+      }
+      let templateEngine = void 0;
+      if (parsedOpts.document.template) {
+        templateEngine = new TemplateEngineRegistry(
+          parsedOpts.document.templateEngines,
+          {
+            rootDir: parsedOpts.document.template,
+            recursive: parsedOpts.document.recursive
+          }
+        );
+        await templateEngine.loadEngines();
+      }
+      const highlighter = await createHighlighter(
+        docs,
+        parsedOpts.syntaxHighlighting.themes
+      );
+      const converters = parsedOpts.document.converters.map(
+        (converter) => converter(parsedOpts, highlighter)
+      );
+      docs.forEach(async (doc) => {
+        const data = await parseData({
+          id: doc.slug,
+          data: {
+            title: doc.title,
+            createdAt: new Date(doc.createdAt),
+            description: doc.preamble
+          }
+        });
+        store.set({
+          id: doc.slug,
+          data,
+          rendered: {
+            html: doc.convert(converters, templateEngine)
+          }
+        });
+      });
+      (0, import_node_process.nextTick)(highlighter.dispose);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asciidocLoader
+});