fuma-content 0.0.2 → 1.0.1

package/dist/internal.d.ts

@@ -1,114 +0,0 @@
-import { Options as Options$1 } from 'fast-glob';
-import { ProcessorOptions } from '@mdx-js/mdx';
-import { VFile } from '@mdx-js/mdx/internal-create-format-aware-processors';
-import { FSWatcher } from 'chokidar';
-
-interface OutputEntry extends Output {
-    /**
-     * extension of file, like: `md`
-     */
-    format: string;
-    file: string;
-}
-interface CompilerWithCache$1 extends Compiler {
-    _compileCache?: Map<string, OutputEntry>;
-}
-declare function compile(this: Compiler): Promise<OutputEntry[]>;
-declare function compileFile(this: CompilerWithCache$1, file: string): Promise<OutputEntry>;
-
-interface Output {
-    dependencies?: OutputEntry[];
-    content: string;
-    _entryPoint?: unknown;
-    _mdx?: {
-        vfile: VFile;
-    };
-}
-type Transformer = (this: Compiler, file: string, source: string) => Output | Promise<Output>;
-
-interface Options extends ProcessorOptions {
-    /**
-     * Fetch last modified time with specified version control
-     * @defaultValue 'none'
-     */
-    lastModifiedTime?: "git" | "none";
-    /**
-     * @defaultValue `['frontmatter', 'lastModified']`
-     */
-    remarkExports?: string[];
-    /**
-     * Convert relative imports into absolute imports
-     *
-     * @defaultValue true
-     */
-    enableAbsoluteImport?: boolean;
-}
-/**
- * Load MDX/markdown files
- */
-declare const loadMDX: ({ lastModifiedTime, format: forceFormat, remarkExports, enableAbsoluteImport, ...rest }?: Options) => Transformer;
-
-interface EntryPointOptions {
-    /**
-     * Notice that `lazy` mode is not supported by `source` function
-     *
-     * @defaultValue 'import'
-     */
-    mode?: "lazy" | "import";
-    /**
-     * Use full-path for `file` property
-     *
-     * @defaultValue false
-     */
-    fullPath?: string;
-}
-declare function loadEntryPoint(this: Compiler, entries: OutputEntry[]): OutputEntry;
-
-interface EmitEntry extends OutputEntry {
-    outputPath: string;
-}
-interface CompilerWithCache extends Compiler {
-    _emitCache?: WeakMap<OutputEntry, EmitEntry>;
-}
-declare function emit(this: Compiler): Promise<void>;
-declare function emitEntry(this: CompilerWithCache, entry: OutputEntry): Promise<EmitEntry>;
-
-declare function watch(this: Compiler): FSWatcher;
-
-interface CompilerOptions {
-    files: string[];
-    cwd: string;
-    outputDir: string;
-    outputExt: string;
-    loaders?: Record<string, Transformer>;
-    entryPoint?: EntryPointOptions;
-    mdxOptions?: Options;
-    globOptions?: Options$1;
-}
-interface Compiler {
-    options: CompilerOptions;
-    /**
-     * Files to compile
-     */
-    files: string[];
-    compile: typeof compile;
-    compileFile: typeof compileFile;
-    emit: typeof emit;
-    emitEntry: typeof emitEntry;
-    watch: typeof watch;
-    loaders: Record<string, Transformer>;
-    _output?: OutputEntry[];
-    _emit?: EmitEntry[];
-}
-
-declare const defaultOptions: {
-    cwd: string;
-    outputDir: string;
-    outputExt: string;
-};
-type CreateCompilerOptions = Pick<Partial<CompilerOptions>, keyof typeof defaultOptions> & Omit<CompilerOptions, keyof typeof defaultOptions>;
-declare function createCompiler(options: CreateCompilerOptions): Promise<Compiler>;
-
-declare const defaultConfig: CreateCompilerOptions;
-
-export { type CreateCompilerOptions, type EntryPointOptions, type Options, createCompiler, defaultConfig, loadEntryPoint, loadMDX };

package/dist/internal.js

@@ -1,420 +0,0 @@
-// src/constants.ts
-var defaultConfig = {
-  files: ["./content/**/*"]
-};
-
-// src/utils/path.ts
-import * as path from "node:path";
-import FastGlob from "fast-glob";
-function getAbsolutePath(cwd, relativePath) {
-  return path.join(cwd, relativePath);
-}
-function getRelativePath(cwd, absolutePath) {
-  return slash(
-    path.join(
-      path.relative(cwd, path.dirname(absolutePath)),
-      path.basename(absolutePath)
-    )
-  );
-}
-function getImportPath(absolutePath) {
-  return slash(absolutePath);
-}
-function slash(anyPath) {
-  const isExtendedLengthPath = anyPath.startsWith("\\\\?\\");
-  if (isExtendedLengthPath) {
-    return anyPath;
-  }
-  return anyPath.replaceAll("\\", "/");
-}
-async function globFiles({
-  cwd,
-  globOptions,
-  files
-}) {
-  return FastGlob.glob(files, {
-    cwd,
-    ...globOptions
-  }).then((result) => result.map((file) => getAbsolutePath(cwd, file)));
-}
-function getOutputPath({ options }, entry) {
-  return path.join(
-    options.cwd,
-    options.outputDir,
-    path.relative(options.cwd, path.dirname(entry.file)),
-    `${path.basename(entry.file, path.extname(entry.file))}${options.outputExt}`
-  );
-}
-
-// src/loader/mdx.ts
-import { createProcessor } from "@mdx-js/mdx";
-import grayMatter from "gray-matter";
-
-// src/utils/git-timpstamp.ts
-import path2 from "node:path";
-import fs from "node:fs";
-import { spawn } from "cross-spawn";
-var cache = /* @__PURE__ */ new Map();
-function getGitTimestamp(file) {
-  const cachedTimestamp = cache.get(file);
-  if (cachedTimestamp) return Promise.resolve(cachedTimestamp);
-  return new Promise((resolve, reject) => {
-    const cwd = path2.dirname(file);
-    if (!fs.existsSync(cwd)) {
-      resolve(void 0);
-      return;
-    }
-    const fileName = path2.basename(file);
-    const child = spawn("git", ["log", "-1", '--pretty="%ai"', fileName], {
-      cwd
-    });
-    let output;
-    child.stdout.on("data", (d) => output = new Date(String(d)));
-    child.on("close", () => {
-      if (output) cache.set(file, output);
-      resolve(output);
-    });
-    child.on("error", reject);
-  });
-}
-
-// src/remark-plugins/utils.ts
-import { valueToEstree } from "estree-util-value-to-estree";
-function getMdastExport(name, value) {
-  return {
-    type: "mdxjsEsm",
-    value: "",
-    data: {
-      estree: {
-        type: "Program",
-        sourceType: "module",
-        body: [
-          {
-            type: "ExportNamedDeclaration",
-            specifiers: [],
-            source: null,
-            declaration: {
-              type: "VariableDeclaration",
-              kind: "const",
-              declarations: [
-                {
-                  type: "VariableDeclarator",
-                  id: {
-                    type: "Identifier",
-                    name
-                  },
-                  init: valueToEstree(value)
-                }
-              ]
-            }
-          }
-        ]
-      }
-    }
-  };
-}
-
-// src/remark-plugins/remark-exports.ts
-function remarkMdxExport({ values }) {
-  return (tree, vfile) => {
-    for (const name of values) {
-      if (!(name in vfile.data)) return;
-      tree.children.unshift(getMdastExport(name, vfile.data[name]));
-    }
-  };
-}
-
-// src/remark-plugins/remark-absolute-import.ts
-import * as path3 from "node:path";
-import { visit } from "unist-util-visit";
-function remarkAbsoluteImport({
-  compiler,
-  transformFormats
-}) {
-  return async (tree, vfile) => {
-    const transforms = [];
-    visit(tree, "mdxjsEsm", (node) => {
-      const body = node.data?.estree?.body ?? [];
-      for (const statement of body) {
-        if (statement.type !== "ImportDeclaration" || typeof statement.source.value !== "string")
-          continue;
-        const value = statement.source.value;
-        if (!value.startsWith("./") && !value.startsWith("../")) continue;
-        const file = path3.join(path3.dirname(vfile.path), value);
-        if (transformFormats.includes(path3.extname(file).slice(1))) {
-          const transform = compiler.compileFile(file).then((entry) => {
-            statement.source.value = getImportPath(
-              getOutputPath(compiler, entry)
-            );
-            delete statement.source.raw;
-            return entry;
-          });
-          transforms.push(transform);
-          continue;
-        }
-        const replace = getImportPath(file);
-        statement.source.value = replace;
-        delete statement.source.raw;
-      }
-    });
-    vfile.data.ctx = { dependencies: await Promise.all(transforms) };
-  };
-}
-
-// src/loader/mdx.ts
-function pluggable(enable, value) {
-  return enable ? [value] : [];
-}
-function getProcessor(compiler, options) {
-  if (!options.format) throw new Error("format is required");
-  compiler._mdxCache ||= /* @__PURE__ */ new Map();
-  let processor = compiler._mdxCache.get(options.format);
-  if (!processor) {
-    processor = createProcessor(options);
-    compiler._mdxCache.set(options.format, processor);
-  }
-  return processor;
-}
-var loadMDX = ({
-  lastModifiedTime,
-  format: forceFormat,
-  remarkExports = ["frontmatter", "lastModified"],
-  enableAbsoluteImport = true,
-  ...rest
-} = {}) => {
-  return async function transform(file, source) {
-    const { content, data: frontmatter } = grayMatter(source);
-    const detectedFormat = file.endsWith(".mdx") ? "mdx" : "md";
-    const format = forceFormat ?? detectedFormat;
-    let timestamp;
-    const processor = getProcessor(this, {
-      format,
-      development: process.env.NODE_ENV === "development",
-      ...rest,
-      remarkPlugins: [
-        ...rest.remarkPlugins ?? [],
-        ...pluggable(enableAbsoluteImport, [
-          remarkAbsoluteImport,
-          {
-            compiler: this,
-            transformFormats: Object.keys(this.loaders)
-          }
-        ]),
-        [remarkMdxExport, { values: remarkExports }]
-      ]
-    });
-    if (lastModifiedTime === "git")
-      timestamp = (await getGitTimestamp(file))?.getTime();
-    const vfile = await processor.process({
-      value: content,
-      path: file,
-      data: {
-        lastModified: timestamp,
-        frontmatter
-      }
-    });
-    return {
-      dependencies: vfile.data.ctx.dependencies,
-      content: String(vfile),
-      _mdx: {
-        vfile
-      }
-    };
-  };
-};
-
-// src/loader/json.ts
-var loadJson = () => {
-  return (_file, source) => {
-    const parsed = JSON.parse(source);
-    return {
-      content: `export default ${JSON.stringify(parsed)}`
-    };
-  };
-};
-
-// src/compiler/emit.ts
-import * as path4 from "node:path";
-import * as fs2 from "node:fs/promises";
-async function emit() {
-  const entires = await this.compile();
-  const emits = entires.map(async (entry) => this.emitEntry(entry));
-  this._emit = await Promise.all(emits);
-}
-async function emitEntry(entry) {
-  this._emitCache ||= /* @__PURE__ */ new WeakMap();
-  const cached = this._emitCache.get(entry);
-  if (cached) return cached;
-  const outputPath = getOutputPath(this, entry);
-  await fs2.mkdir(path4.dirname(outputPath), { recursive: true });
-  await fs2.writeFile(outputPath, entry.content);
-  if (entry.dependencies) {
-    await Promise.all(entry.dependencies.map((dep) => this.emitEntry(dep)));
-  }
-  const output = {
-    ...entry,
-    outputPath
-  };
-  this._emitCache.set(entry, output);
-  return output;
-}
-
-// src/compiler/compile.ts
-import * as fs3 from "node:fs/promises";
-import * as path5 from "node:path";
-
-// src/loader/entry-point.ts
-function loadEntryPoint(entries) {
-  const { mode = "import" } = this.options.entryPoint ?? {};
-  let content;
-  switch (mode) {
-    case "import":
-      content = generateImport(this, entries);
-      break;
-    default:
-      content = generateLazy(this, entries);
-      break;
-  }
-  return {
-    format: "js",
-    file: getAbsolutePath(this.options.cwd, "./index.js"),
-    content,
-    _entryPoint: {}
-  };
-}
-function generateImport(compiler, output) {
-  const { fullPath = false } = compiler.options.entryPoint ?? {};
-  const formats = /* @__PURE__ */ new Map();
-  output.forEach((entry, i) => {
-    const b = formats.get(entry.format) ?? { imports: [], entries: [] };
-    formats.set(entry.format, b);
-    const importPath = getImportPath(getOutputPath(compiler, entry));
-    const file = fullPath ? entry.file : getRelativePath(compiler.options.cwd, entry.file);
-    const name = `p_${i.toString()}`;
-    b.imports.push(`import * as ${name} from ${JSON.stringify(importPath)};`);
-    b.entries.push(`{
-...${name},
-file: ${JSON.stringify(file)},
-}`);
-  });
-  const imports = Array.from(formats.values()).flatMap((f) => f.imports).join("\n");
-  const entires = Array.from(formats.entries()).map(([k, v]) => `${k}: [${v.entries.join(",")}]`).join(",");
-  return `${imports}
-export default {${entires}};`;
-}
-function generateLazy(compiler, output) {
-  const entries = [];
-  for (const entry of output) {
-    const fronmatter = entry._mdx ? entry._mdx.vfile.data.frontmatter : {};
-    const importPath = getImportPath(getOutputPath(compiler, entry));
-    const line = `{
-file: ${JSON.stringify(entry.file)},
-info: ${JSON.stringify(fronmatter)},
-load: () => import(${JSON.stringify(importPath)})
-}`;
-    entries.push(line);
-  }
-  return `export default [${entries.join(",\n")}]`;
-}
-
-// src/compiler/compile.ts
-async function compile() {
-  const output = [];
-  await Promise.all(
-    this.files.map(async (file) => {
-      const entry = await this.compileFile(file);
-      output.push(entry);
-    })
-  );
-  output.push(loadEntryPoint.call(this, output));
-  this._output = output;
-  return output;
-}
-async function compileFile(file) {
-  this._compileCache ||= /* @__PURE__ */ new Map();
-  const cache2 = this._compileCache.get(file);
-  if (cache2) return cache2;
-  const format = path5.extname(file).slice(1);
-  const content = (await fs3.readFile(file)).toString();
-  const loader = this.loaders[format];
-  const output = await loader?.call(this, file, content);
-  if (!output) {
-    throw new Error(`Unknown format: ${format}`);
-  }
-  const entry = {
-    file,
-    format,
-    ...output
-  };
-  this._compileCache.set(file, entry);
-  return entry;
-}
-function removeCache(compiler, file) {
-  compiler._compileCache?.delete(file);
-}
-
-// src/compiler/watch.ts
-import { watch as watchFn } from "chokidar";
-function watch() {
-  void this.emit();
-  const watcher = watchFn(this.options.files, { cwd: this.options.cwd });
-  watcher.on("all", (eventName, relativePath) => {
-    const absolutePath = getAbsolutePath(this.options.cwd, relativePath);
-    if (eventName === "add" && !this.files.includes(absolutePath)) {
-      this.files.push(absolutePath);
-      void this.emit();
-    }
-    if (eventName === "unlink") {
-      this.files = this.files.filter((file) => file !== absolutePath);
-      removeCache(this, absolutePath);
-      void this.emit();
-    }
-    if (eventName === "change") {
-      console.log("update", relativePath);
-      removeCache(this, absolutePath);
-      void this.compileFile(absolutePath).then(async (entry) => {
-        await this.emitEntry(entry);
-      });
-    }
-  });
-  return watcher;
-}
-
-// src/compiler/index.ts
-var defaultOptions = {
-  cwd: process.cwd(),
-  outputDir: "./dist",
-  outputExt: ".js"
-};
-async function createCompiler(options) {
-  const compilerOptions = {
-    ...defaultOptions,
-    ...options
-  };
-  const files = await globFiles(compilerOptions);
-  return {
-    files,
-    options: compilerOptions,
-    compile,
-    emitEntry,
-    watch,
-    emit,
-    compileFile,
-    loaders: createLoaders(compilerOptions)
-  };
-}
-function createLoaders(options) {
-  const mdx = loadMDX(options.mdxOptions);
-  return {
-    mdx,
-    md: mdx,
-    json: loadJson(),
-    ...options.loaders
-  };
-}
-export {
-  createCompiler,
-  defaultConfig,
-  loadEntryPoint,
-  loadMDX
-};