@astrojs/markdoc 0.0.0-10745-20240410180016

package/dist/load-config.js

@@ -0,0 +1,91 @@
+import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import { build as esbuild } from "esbuild";
+import { MarkdocError } from "./utils.js";
+const SUPPORTED_MARKDOC_CONFIG_FILES = [
+  "markdoc.config.js",
+  "markdoc.config.mjs",
+  "markdoc.config.mts",
+  "markdoc.config.ts"
+];
+async function loadMarkdocConfig(astroConfig) {
+  let markdocConfigUrl;
+  for (const filename of SUPPORTED_MARKDOC_CONFIG_FILES) {
+    const filePath = new URL(filename, astroConfig.root);
+    if (!fs.existsSync(filePath))
+      continue;
+    markdocConfigUrl = filePath;
+    break;
+  }
+  if (!markdocConfigUrl)
+    return;
+  const { code } = await bundleConfigFile({
+    markdocConfigUrl,
+    astroConfig
+  });
+  const config = await loadConfigFromBundledFile(astroConfig.root, code);
+  return {
+    config,
+    fileUrl: markdocConfigUrl
+  };
+}
+async function bundleConfigFile({
+  markdocConfigUrl,
+  astroConfig
+}) {
+  let markdocError;
+  const result = await esbuild({
+    absWorkingDir: fileURLToPath(astroConfig.root),
+    entryPoints: [fileURLToPath(markdocConfigUrl)],
+    outfile: "out.js",
+    write: false,
+    target: ["node16"],
+    platform: "node",
+    packages: "external",
+    bundle: true,
+    format: "esm",
+    sourcemap: "inline",
+    metafile: true,
+    plugins: [
+      {
+        name: "stub-astro-imports",
+        setup(build) {
+          build.onResolve({ filter: /.*\.astro$/ }, () => {
+            markdocError = new MarkdocError({
+              message: "`.astro` files are no longer supported in the Markdoc config.",
+              hint: "Use the `component()` utility to specify a component path instead. See https://docs.astro.build/en/guides/integrations-guide/markdoc/"
+            });
+            return {
+              // Stub with an unused default export.
+              path: "data:text/javascript,export default true",
+              external: true
+            };
+          });
+        }
+      }
+    ]
+  });
+  if (markdocError)
+    throw markdocError;
+  const { text } = result.outputFiles[0];
+  return {
+    code: text,
+    dependencies: result.metafile ? Object.keys(result.metafile.inputs) : []
+  };
+}
+async function loadConfigFromBundledFile(root, code) {
+  const tmpFileUrl = new URL(`markdoc.config.timestamp-${Date.now()}.mjs`, root);
+  fs.writeFileSync(tmpFileUrl, code);
+  try {
+    return (await import(tmpFileUrl.pathname)).default;
+  } finally {
+    try {
+      fs.unlinkSync(tmpFileUrl);
+    } catch {
+    }
+  }
+}
+export {
+  SUPPORTED_MARKDOC_CONFIG_FILES,
+  loadMarkdocConfig
+};

package/dist/options.d.ts

@@ -0,0 +1,4 @@
+export interface MarkdocIntegrationOptions {
+    allowHTML?: boolean;
+    ignoreIndentation?: boolean;
+}

package/dist/runtime-assets-config.d.ts

@@ -0,0 +1,2 @@
+import type { Config as MarkdocConfig } from '@markdoc/markdoc';
+export declare const assetsConfig: MarkdocConfig;

package/dist/runtime-assets-config.js

@@ -0,0 +1,25 @@
+import Markdoc from "@markdoc/markdoc";
+import { Image } from "astro:assets";
+const assetsConfig = {
+  nodes: {
+    image: {
+      attributes: {
+        ...Markdoc.nodes.image.attributes,
+        __optimizedSrc: { type: "Object" }
+      },
+      transform(node, config) {
+        const attributes = node.transformAttributes(config);
+        const children = node.transformChildren(config);
+        if (node.type === "image" && "__optimizedSrc" in node.attributes) {
+          const { __optimizedSrc, ...rest } = node.attributes;
+          return new Markdoc.Tag(Image, { ...rest, src: __optimizedSrc }, children);
+        } else {
+          return new Markdoc.Tag("img", attributes, children);
+        }
+      }
+    }
+  }
+};
+export {
+  assetsConfig
+};

package/dist/runtime.d.ts

@@ -0,0 +1,29 @@
+import type { MarkdownHeading } from '@astrojs/markdown-remark';
+import { type NodeType, type RenderableTreeNode } from '@markdoc/markdoc';
+import type { AstroInstance } from 'astro';
+import { type AstroMarkdocConfig } from './config.js';
+import type { MarkdocIntegrationOptions } from './options.js';
+/**
+ * Merge user config with default config and set up context (ex. heading ID slugger)
+ * Called on each file's individual transform.
+ * TODO: virtual module to merge configs per-build instead of per-file?
+ */
+export declare function setupConfig(userConfig: AstroMarkdocConfig | undefined, options: MarkdocIntegrationOptions | undefined): Promise<MergedConfig>;
+/** Used for synchronous `getHeadings()` function */
+export declare function setupConfigSync(userConfig: AstroMarkdocConfig | undefined, options: MarkdocIntegrationOptions | undefined): MergedConfig;
+type MergedConfig = Required<Omit<AstroMarkdocConfig, 'extends'>>;
+/** Merge function from `@markdoc/markdoc` internals */
+export declare function mergeConfig(configA: AstroMarkdocConfig, configB: AstroMarkdocConfig): MergedConfig;
+export declare function resolveComponentImports(markdocConfig: Required<Pick<AstroMarkdocConfig, 'tags' | 'nodes'>>, tagComponentMap: Record<string, AstroInstance['default']>, nodeComponentMap: Record<NodeType, AstroInstance['default']>): Required<Pick<AstroMarkdocConfig, "nodes" | "tags">>;
+/**
+ * Get text content as a string from a Markdoc transform AST
+ */
+export declare function getTextContent(childNodes: RenderableTreeNode[]): string;
+/**
+ * Collect headings from Markdoc transform AST
+ * for `headings` result on `render()` return value
+ */
+export declare function collectHeadings(children: RenderableTreeNode[], collectedHeadings: MarkdownHeading[]): void;
+export declare function createGetHeadings(stringifiedAst: string, userConfig: AstroMarkdocConfig, options: MarkdocIntegrationOptions | undefined): () => MarkdownHeading[];
+export declare function createContentComponent(Renderer: AstroInstance['default'], stringifiedAst: string, userConfig: AstroMarkdocConfig, options: MarkdocIntegrationOptions | undefined, tagComponentMap: Record<string, AstroInstance['default']>, nodeComponentMap: Record<NodeType, AstroInstance['default']>): import("astro/runtime/server/index.js").AstroComponentFactory;
+export {};

package/dist/runtime.js

@@ -0,0 +1,152 @@
+import Markdoc, {
+} from "@markdoc/markdoc";
+import { createComponent, renderComponent } from "astro/runtime/server/index.js";
+import {} from "./config.js";
+import { setupHeadingConfig } from "./heading-ids.js";
+import { htmlTag } from "./html/tagdefs/html.tag.js";
+async function setupConfig(userConfig = {}, options) {
+  let defaultConfig = setupHeadingConfig();
+  if (userConfig.extends) {
+    for (let extension of userConfig.extends) {
+      if (extension instanceof Promise) {
+        extension = await extension;
+      }
+      defaultConfig = mergeConfig(defaultConfig, extension);
+    }
+  }
+  let merged = mergeConfig(defaultConfig, userConfig);
+  if (options?.allowHTML) {
+    merged = mergeConfig(merged, HTML_CONFIG);
+  }
+  return merged;
+}
+function setupConfigSync(userConfig = {}, options) {
+  const defaultConfig = setupHeadingConfig();
+  let merged = mergeConfig(defaultConfig, userConfig);
+  if (options?.allowHTML) {
+    merged = mergeConfig(merged, HTML_CONFIG);
+  }
+  return merged;
+}
+function mergeConfig(configA, configB) {
+  return {
+    ...configA,
+    ...configB,
+    ctx: {
+      ...configA.ctx,
+      ...configB.ctx
+    },
+    tags: {
+      ...configA.tags,
+      ...configB.tags
+    },
+    nodes: {
+      ...configA.nodes,
+      ...configB.nodes
+    },
+    functions: {
+      ...configA.functions,
+      ...configB.functions
+    },
+    variables: {
+      ...configA.variables,
+      ...configB.variables
+    },
+    partials: {
+      ...configA.partials,
+      ...configB.partials
+    },
+    validation: {
+      ...configA.validation,
+      ...configB.validation
+    }
+  };
+}
+function resolveComponentImports(markdocConfig, tagComponentMap, nodeComponentMap) {
+  for (const [tag, render] of Object.entries(tagComponentMap)) {
+    const config = markdocConfig.tags[tag];
+    if (config)
+      config.render = render;
+  }
+  for (const [node, render] of Object.entries(nodeComponentMap)) {
+    const config = markdocConfig.nodes[node];
+    if (config)
+      config.render = render;
+  }
+  return markdocConfig;
+}
+function getTextContent(childNodes) {
+  let text = "";
+  for (const node of childNodes) {
+    if (typeof node === "string" || typeof node === "number") {
+      text += node;
+    } else if (typeof node === "object" && Markdoc.Tag.isTag(node)) {
+      text += getTextContent(node.children);
+    }
+  }
+  return text;
+}
+const headingLevels = [1, 2, 3, 4, 5, 6];
+function collectHeadings(children, collectedHeadings) {
+  for (const node of children) {
+    if (typeof node !== "object" || !Markdoc.Tag.isTag(node))
+      continue;
+    if (node.attributes.__collectHeading === true && typeof node.attributes.level === "number") {
+      collectedHeadings.push({
+        slug: node.attributes.id,
+        depth: node.attributes.level,
+        text: getTextContent(node.children)
+      });
+      continue;
+    }
+    for (const level of headingLevels) {
+      if (node.name === "h" + level) {
+        collectedHeadings.push({
+          slug: node.attributes.id,
+          depth: level,
+          text: getTextContent(node.children)
+        });
+      }
+    }
+    collectHeadings(node.children, collectedHeadings);
+  }
+}
+function createGetHeadings(stringifiedAst, userConfig, options) {
+  return function getHeadings() {
+    const config = setupConfigSync(userConfig, options);
+    const ast = Markdoc.Ast.fromJSON(stringifiedAst);
+    const content = Markdoc.transform(ast, config);
+    let collectedHeadings = [];
+    collectHeadings(Array.isArray(content) ? content : [content], collectedHeadings);
+    return collectedHeadings;
+  };
+}
+function createContentComponent(Renderer, stringifiedAst, userConfig, options, tagComponentMap, nodeComponentMap) {
+  return createComponent({
+    async factory(result, props) {
+      const withVariables = mergeConfig(userConfig, { variables: props });
+      const config = resolveComponentImports(
+        await setupConfig(withVariables, options),
+        tagComponentMap,
+        nodeComponentMap
+      );
+      return renderComponent(result, Renderer.name, Renderer, { stringifiedAst, config }, {});
+    },
+    propagation: "self"
+  });
+}
+const HTML_CONFIG = {
+  tags: {
+    "html-tag": htmlTag
+  }
+};
+export {
+  collectHeadings,
+  createContentComponent,
+  createGetHeadings,
+  getTextContent,
+  mergeConfig,
+  resolveComponentImports,
+  setupConfig,
+  setupConfigSync
+};

package/dist/tokenizer.d.ts

@@ -0,0 +1,3 @@
+import type { Tokenizer } from '@markdoc/markdoc';
+import type { MarkdocIntegrationOptions } from './options.js';
+export declare function getMarkdocTokenizer(options: MarkdocIntegrationOptions | undefined): Tokenizer;

package/dist/tokenizer.js

@@ -0,0 +1,27 @@
+import Markdoc from "@markdoc/markdoc";
+function getMarkdocTokenizer(options) {
+  const key = cacheKey(options);
+  if (!_cachedMarkdocTokenizers[key]) {
+    const tokenizerOptions = {
+      // Strip <!-- comments --> from rendered output
+      // Without this, they're rendered as strings!
+      allowComments: true
+    };
+    if (options?.allowHTML) {
+      tokenizerOptions.allowIndentation = true;
+      tokenizerOptions.html = true;
+    }
+    if (options?.ignoreIndentation) {
+      tokenizerOptions.allowIndentation = true;
+    }
+    _cachedMarkdocTokenizers[key] = new Markdoc.Tokenizer(tokenizerOptions);
+  }
+  return _cachedMarkdocTokenizers[key];
+}
+let _cachedMarkdocTokenizers = {};
+function cacheKey(options) {
+  return JSON.stringify(options);
+}
+export {
+  getMarkdocTokenizer
+};

package/dist/utils.d.ts

@@ -0,0 +1,46 @@
+import type { ComponentConfig } from './config.js';
+/**
+ * Matches AstroError object with types like error codes stubbed out
+ * @see 'astro/src/core/errors/errors.ts'
+ */
+export declare class MarkdocError extends Error {
+    loc: ErrorLocation | undefined;
+    title: string | undefined;
+    hint: string | undefined;
+    frame: string | undefined;
+    type: string;
+    constructor(props: ErrorProperties, ...params: any);
+}
+interface ErrorLocation {
+    file?: string;
+    line?: number;
+    column?: number;
+}
+interface ErrorProperties {
+    code?: number;
+    title?: string;
+    name?: string;
+    message?: string;
+    location?: ErrorLocation;
+    hint?: string;
+    stack?: string;
+    frame?: string;
+}
+/**
+ * @see 'astro/src/core/path.ts'
+ */
+export declare function prependForwardSlash(str: string): string;
+export declare function isValidUrl(str: string): boolean;
+/**
+ * Identifies Astro components with propagated assets
+ * @see 'packages/astro/src/content/consts.ts'
+ */
+export declare const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
+/**
+ * @see 'packages/astro/src/content/utils.ts'
+ */
+export declare function hasContentFlag(viteId: string, flag: string): boolean;
+/** Identifier for components imports passed as `tags` or `nodes` configuration. */
+export declare const componentConfigSymbol: unique symbol;
+export declare function isComponentConfig(value: unknown): value is ComponentConfig;
+export {};

package/dist/utils.js

@@ -0,0 +1,47 @@
+class MarkdocError extends Error {
+  loc;
+  title;
+  hint;
+  frame;
+  type = "MarkdocError";
+  constructor(props, ...params) {
+    super(...params);
+    const { title = "MarkdocError", message, stack, location, hint, frame } = props;
+    this.title = title;
+    if (message)
+      this.message = message;
+    this.stack = stack ? stack : this.stack;
+    this.loc = location;
+    this.hint = hint;
+    this.frame = frame;
+  }
+}
+function prependForwardSlash(str) {
+  return str[0] === "/" ? str : "/" + str;
+}
+function isValidUrl(str) {
+  try {
+    new URL(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
+function hasContentFlag(viteId, flag) {
+  const flags = new URLSearchParams(viteId.split("?")[1] ?? "");
+  return flags.has(flag);
+}
+const componentConfigSymbol = Symbol.for("@astrojs/markdoc/component-config");
+function isComponentConfig(value) {
+  return typeof value === "object" && value !== null && componentConfigSymbol in value;
+}
+export {
+  MarkdocError,
+  PROPAGATED_ASSET_FLAG,
+  componentConfigSymbol,
+  hasContentFlag,
+  isComponentConfig,
+  isValidUrl,
+  prependForwardSlash
+};

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@astrojs/markdoc",
+  "description": "Add support for Markdoc in your Astro site",
+  "version": "0.0.0-10745-20240410180016",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "author": "withastro",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/withastro/astro.git",
+    "directory": "packages/integrations/markdoc"
+  },
+  "keywords": [
+    "astro-integration",
+    "astro-component",
+    "markdoc"
+  ],
+  "bugs": "https://github.com/withastro/astro/issues",
+  "homepage": "https://docs.astro.build/en/guides/integrations-guide/markdoc/",
+  "exports": {
+    "./prism": {
+      "types": "./dist/extensions/prism.d.ts",
+      "default": "./dist/extensions/prism.js"
+    },
+    "./shiki": {
+      "types": "./dist/extensions/shiki.d.ts",
+      "default": "./dist/extensions/shiki.js"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "default": "./dist/config.js"
+    },
+    ".": "./dist/index.js",
+    "./components": "./components/index.ts",
+    "./runtime": "./dist/runtime.js",
+    "./runtime-assets-config": "./dist/runtime-assets-config.js",
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "config": [
+        "./dist/config.d.ts"
+      ],
+      "prism": [
+        "./dist/extensions/prism.d.ts"
+      ],
+      "shiki": [
+        "./dist/extensions/shiki.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "components",
+    "dist",
+    "template"
+  ],
+  "dependencies": {
+    "@markdoc/markdoc": "^0.3.5",
+    "esbuild": "^0.19.6",
+    "github-slugger": "^2.0.0",
+    "gray-matter": "^4.0.3",
+    "htmlparser2": "^9.0.0",
+    "kleur": "^4.1.5",
+    "zod": "^3.22.4",
+    "@astrojs/internal-helpers": "0.4.0",
+    "@astrojs/markdown-remark": "0.0.0-10745-20240410180016",
+    "@astrojs/prism": "0.0.0-10745-20240410180016"
+  },
+  "peerDependencies": {
+    "astro": "0.0.0-10745-20240410180016"
+  },
+  "devDependencies": {
+    "@types/html-escaper": "^3.0.2",
+    "@types/markdown-it": "^13.0.6",
+    "devalue": "^4.3.2",
+    "linkedom": "^0.16.4",
+    "vite": "^5.1.4",
+    "astro": "0.0.0-10745-20240410180016",
+    "astro-scripts": "0.0.14"
+  },
+  "engines": {
+    "node": "^18.17.1 || ^20.3.0 || >=21.0.0"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "scripts": {
+    "build": "astro-scripts build \"src/**/*.ts\" && tsc",
+    "build:ci": "astro-scripts build \"src/**/*.ts\"",
+    "dev": "astro-scripts dev \"src/**/*.ts\"",
+    "test": "astro-scripts test --timeout 60000 \"test/**/*.test.js\""
+  }
+}

package/template/content-module-types.d.ts

@@ -0,0 +1,8 @@
+declare module 'astro:content' {
+	interface Render {
+		'.mdoc': Promise<{
+			Content(props: Record<string, any>): import('astro').MarkdownInstance<{}>['Content'];
+			headings: import('astro').MarkdownHeading[];
+		}>;
+	}
+}