@d10f/asciidoc-astro-loader 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,13 @@
+import { LoaderContext } from 'astro/loaders';
+import { A as AsciidocLoader } from './index-Cf7MF6tZ.cjs';
+export { a as AsciidocTemplate, C as CustomConverterFactoryFn, F as FilesystemTemplate, N as NodeContext, R as RawTemplate } from './index-Cf7MF6tZ.cjs';
+import 'shiki';
+import 'asciidoctor';
+import 'zod';
+
+declare function asciidocLoader(options: AsciidocLoader): {
+    name: string;
+    load({ config, parseData, store, logger }: LoaderContext): Promise<void>;
+};
+
+export { asciidocLoader };

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { LoaderContext } from 'astro/loaders';
+import { A as AsciidocLoader } from './index-Cf7MF6tZ.js';
+export { a as AsciidocTemplate, C as CustomConverterFactoryFn, F as FilesystemTemplate, N as NodeContext, R as RawTemplate } from './index-Cf7MF6tZ.js';
+import 'shiki';
+import 'asciidoctor';
+import 'zod';
+
+declare function asciidocLoader(options: AsciidocLoader): {
+    name: string;
+    load({ config, parseData, store, logger }: LoaderContext): Promise<void>;
+};
+
+export { asciidocLoader };

package/dist/index.js

@@ -0,0 +1,402 @@
+import {
+  sourceCodeConverter
+} from "./chunk-HAZIHU2Y.js";
+import {
+  slugify,
+  splitFilenameComponents
+} from "./chunk-DDIUST2Z.js";
+import {
+  HandlebarsEngine,
+  NunjucksEngine
+} from "./chunk-2F52PMNV.js";
+
+// src/loader.ts
+import { readdirSync as readdirSync2, realpathSync } from "fs";
+import { nextTick } from "process";
+
+// src/lib/asciidoc/AsciidocDocument.ts
+import Asciidoctor from "asciidoctor";
+
+// 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
+import { readdirSync } from "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 }) {
+    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 = Asciidoctor();
+    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
+import { z as z3 } from "zod";
+
+// src/schemas/document.ts
+import { resolve } from "path";
+import { z } from "zod";
+var documentOptionsSchema = z.looseObject({
+  mode: z.union([z.literal("safe"), z.literal("unsafe")]).default("safe"),
+  template: z.string().default("").transform((val) => resolve(process.cwd(), val)),
+  recursive: z.boolean().default(false)
+}).default({
+  mode: "safe",
+  template: "",
+  recursive: false
+});
+
+// src/schemas/shiki.ts
+import { z as z2 } from "zod";
+var shikiOptionsSchema = z2.object({
+  theme: z2.union([
+    z2.string(),
+    z2.object({
+      light: z2.string(),
+      dark: z2.string()
+    }).catchall(z2.string())
+  ]).transform(transformThemeProp).default({
+    light: "catppuccin-latte",
+    dark: "catppuccin-macchiato"
+  }),
+  defaultColor: z2.string().default("light-dark()"),
+  cssVariablePrefix: z2.string().default("--shiki-"),
+  mergeWhitespaces: z2.union([z2.boolean(), z2.literal("never")]).default(true),
+  tabindex: z2.union([z2.number(), z2.string(), z2.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 = z3.object({
+  tableOfContents: z3.boolean().default(true),
+  maxLevel: z3.number().max(6).min(1).default(3),
+  position: z3.union([z3.literal("before"), z3.literal("after")]).default("after")
+}).default({
+  tableOfContents: true,
+  maxLevel: 3,
+  position: "after"
+});
+var loaderOptionsSchema = z3.object({
+  base: z3.string(),
+  document: documentOptionsSchema,
+  syntaxHighlighting: shikiOptionsSchema,
+  preamble: preambleOptionsSchema
+});
+
+// src/lib/shiki/Highlighter.ts
+import { createHighlighterCore, createJavaScriptRegexEngine } from "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 createHighlighterCore({
+    themes: Object.values(themes).map((theme) => {
+      return import(`@shikijs/themes/${theme}`);
+    }),
+    langs: Array.from(langs).map((lang) => {
+      return import(`@shikijs/langs/${lang}`);
+    }),
+    engine: createJavaScriptRegexEngine()
+  });
+  return Object.freeze(highlighter);
+}
+
+// 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(".") ? realpathSync(options.base) : root + options.base;
+      const docs = readdirSync2(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)
+          }
+        });
+      });
+      nextTick(highlighter.dispose);
+    }
+  };
+}
+export {
+  asciidocLoader
+};

package/dist/lib/asciidoc/converters/index.cjs

@@ -0,0 +1,178 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/asciidoc/converters/index.ts
+var converters_exports = {};
+__export(converters_exports, {
+  sourceCodeConverter: () => sourceCodeConverter
+});
+module.exports = __toCommonJS(converters_exports);
+
+// src/lib/asciidoc/converters/sourceCodeConverter.ts
+var import_transformers = require("@shikijs/transformers");
+var import_node_path = require("path");
+
+// src/lib/utils.ts
+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/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_path.resolve)(process.cwd(), template);
+            if (engine.canRenderFile) {
+              return engine.renderFile(templateFile, {
+                content: output,
+                lang
+              });
+            }
+          }
+        }
+        return output;
+      }
+    };
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sourceCodeConverter
+});

package/dist/lib/asciidoc/converters/index.d.cts

@@ -0,0 +1,13 @@
+import { ShikiTransformer } from 'shiki';
+import { C as CustomConverterFactoryFn, N as NodeContext } from '../../../index-Cf7MF6tZ.cjs';
+import 'asciidoctor';
+import 'zod';
+
+type CodeBlockConverterOptions = {
+    nodeContext: NodeContext;
+    transformers: ShikiTransformer[];
+    template: string;
+};
+declare const sourceCodeConverter: CustomConverterFactoryFn<Partial<CodeBlockConverterOptions>>;
+
+export { sourceCodeConverter };

package/dist/lib/asciidoc/converters/index.d.ts

@@ -0,0 +1,13 @@
+import { ShikiTransformer } from 'shiki';
+import { C as CustomConverterFactoryFn, N as NodeContext } from '../../../index-Cf7MF6tZ.js';
+import 'asciidoctor';
+import 'zod';
+
+type CodeBlockConverterOptions = {
+    nodeContext: NodeContext;
+    transformers: ShikiTransformer[];
+    template: string;
+};
+declare const sourceCodeConverter: CustomConverterFactoryFn<Partial<CodeBlockConverterOptions>>;
+
+export { sourceCodeConverter };

package/dist/lib/asciidoc/converters/index.js

@@ -0,0 +1,7 @@
+import {
+  sourceCodeConverter
+} from "../../../chunk-HAZIHU2Y.js";
+import "../../../chunk-DDIUST2Z.js";
+export {
+  sourceCodeConverter
+};