up n_m

node_modules/@mdx-js/mdx/lib/util/create-format-aware-processors.js

@@ -0,0 +1,89 @@
+/**
+ * @typedef {import('estree-jsx').Program} Program
+ * @typedef {import('mdast').Root} Root
+ * @typedef {import('unified').Processor<Root, Program, Program, Program, string>} Processor
+ * @typedef {import('vfile').Compatible} Compatible
+ * @typedef {import('vfile').VFile} VFile
+ * @typedef {import('../compile.js').CompileOptions} CompileOptions
+ */
+
+/**
+ * @typedef FormatAwareProcessors
+ *   Result.
+ * @property {ReadonlyArray<string>} extnames
+ *   Extensions to use.
+ * @property {Process} process
+ *   Smart processor, async.
+ *
+ * @callback Process
+ *   Smart processor.
+ * @param {Compatible} vfileCompatible
+ *   MDX or markdown document.
+ * @return {Promise<VFile>}
+ *   File.
+ */
+
+import {createProcessor} from '../core.js'
+import {md, mdx} from './extnames.js'
+import {resolveFileAndOptions} from './resolve-file-and-options.js'
+
+/**
+ * Create smart processors to handle different formats.
+ *
+ * @param {Readonly<CompileOptions> | null | undefined} [compileOptions]
+ *   Configuration (optional).
+ * @return {FormatAwareProcessors}
+ *   Smart processor.
+ */
+export function createFormatAwareProcessors(compileOptions) {
+  const compileOptions_ = compileOptions || {}
+  const mdExtensions = compileOptions_.mdExtensions || md
+  const mdxExtensions = compileOptions_.mdxExtensions || mdx
+  /** @type {Processor} */
+  let cachedMarkdown
+  /** @type {Processor} */
+  let cachedMdx
+
+  return {
+    extnames:
+      compileOptions_.format === 'md'
+        ? mdExtensions
+        : compileOptions_.format === 'mdx'
+          ? mdxExtensions
+          : [...mdExtensions, ...mdxExtensions],
+    process
+  }
+
+  /**
+   * Smart processor.
+   *
+   * @type {Process}
+   */
+  function process(vfileCompatible) {
+    const {file, processor} = split(vfileCompatible)
+    return processor.process(file)
+  }
+
+  /**
+   * Make a full vfile from what’s given, and figure out which processor
+   * should be used for it.
+   * This caches processors (one for markdown and one for MDX) so that they do
+   * not have to be reconstructed for each file.
+   *
+   * @param {Compatible} vfileCompatible
+   *   MDX or markdown document.
+   * @return {{file: VFile, processor: Processor}}
+   *   File and corresponding processor.
+   */
+  function split(vfileCompatible) {
+    const {file, options} = resolveFileAndOptions(
+      vfileCompatible,
+      compileOptions_
+    )
+    const processor =
+      options.format === 'md'
+        ? cachedMarkdown || (cachedMarkdown = createProcessor(options))
+        : cachedMdx || (cachedMdx = createProcessor(options))
+    return {file, processor}
+  }
+}