fuma-content 0.0.0

package/dist/chunk-UDFHC2Y3.js

@@ -0,0 +1,347 @@
+// src/constants.ts
+var defaultConfig = {
+  files: ["./content/**/*"]
+};
+var defaultConfigPath = "./fc.config.js";
+
+// src/loader/mdx.ts
+import { createProcessor } from "@mdx-js/mdx";
+import grayMatter from "gray-matter";
+
+// src/utils/git-timpstamp.ts
+import path 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 = path.dirname(file);
+    if (!fs.existsSync(cwd)) {
+      resolve(void 0);
+      return;
+    }
+    const fileName = path.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/loader/mdx.ts
+var cache2 = /* @__PURE__ */ new Map();
+var loadMDX = ({
+  lastModifiedTime,
+  format: forceFormat,
+  remarkExports = ["frontmatter"],
+  ...rest
+} = {}) => {
+  return async (filePath, source) => {
+    const { content, data: frontmatter } = grayMatter(source);
+    const detectedFormat = filePath.endsWith(".mdx") ? "mdx" : "md";
+    const format = forceFormat ?? detectedFormat;
+    let timestamp;
+    let processor = cache2.get(format);
+    if (processor === void 0) {
+      processor = createProcessor({
+        format,
+        development: process.env.NODE_ENV === "development",
+        ...rest,
+        remarkPlugins: [
+          ...rest.remarkPlugins ?? [],
+          [remarkMdxExport, { values: remarkExports }]
+        ]
+      });
+      cache2.set(format, processor);
+    }
+    if (lastModifiedTime === "git")
+      timestamp = (await getGitTimestamp(filePath))?.getTime();
+    const file = await processor.process({
+      value: content,
+      path: filePath,
+      data: {
+        lastModified: timestamp,
+        frontmatter
+      }
+    });
+    return {
+      content: String(file),
+      _mdx: {
+        vfile: file
+      }
+    };
+  };
+};
+
+// src/loader/entry-point.ts
+import { pathToFileURL } from "node:url";
+
+// src/utils/path.ts
+import * as path2 from "node:path";
+import FastGlob from "fast-glob";
+function getAbsolutePath(cwd, relativePath) {
+  return FastGlob.escapePath(path2.join(cwd, relativePath));
+}
+function getRelativePath(cwd, absolutePath) {
+  return path2.join(
+    path2.relative(cwd, path2.dirname(absolutePath)),
+    path2.basename(absolutePath)
+  );
+}
+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 path2.join(
+    options.cwd,
+    options.outputDir,
+    path2.relative(options.cwd, path2.dirname(entry.file)),
+    `${path2.basename(entry.file, path2.extname(entry.file))}${options.outputExt}`
+  );
+}
+
+// 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 = pathToFileURL(getOutputPath(compiler, entry));
+    const file = fullPath ? entry.file : getRelativePath(compiler.options.cwd, entry.file);
+    const name = `p_${i}`;
+    b.imports.push(`import * as ${name} from ${JSON.stringify(importPath)};`);
+    b.entries.push(`{
+...${name},
+format: ${JSON.stringify(entry.format)},
+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 = pathToFileURL(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/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 path3 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) {
+  const outputPath = getOutputPath(this, entry);
+  await fs2.mkdir(path3.dirname(outputPath), { recursive: true });
+  await fs2.writeFile(outputPath, entry.content);
+  return {
+    ...entry,
+    outputPath
+  };
+}
+
+// src/compiler/compile.ts
+import * as fs3 from "node:fs/promises";
+import * as path4 from "node:path";
+async function compile() {
+  this._output = await Promise.all(
+    this.files.map((file) => this.compileFile(file))
+  );
+  this._output.push(loadEntryPoint.call(this, this._output));
+  return this._output;
+}
+async function compileFile(file) {
+  const cache3 = this._cache.get(file);
+  if (cache3)
+    return cache3;
+  const format = path4.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._cache.set(file, entry);
+  return entry;
+}
+
+// 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, path5) => {
+    const absolutePath = getAbsolutePath(this.options.cwd, path5);
+    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);
+      this._cache.delete(absolutePath);
+      void this.emit();
+    }
+    if (eventName === "change") {
+      console.log("update", path5);
+      this._cache.delete(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),
+    _cache: /* @__PURE__ */ new Map()
+  };
+}
+function createLoaders(options) {
+  const mdx = loadMDX(options.mdxOptions);
+  return {
+    mdx,
+    md: mdx,
+    json: loadJson(),
+    ...options.loaders
+  };
+}
+
+export {
+  defaultConfig,
+  defaultConfigPath,
+  loadMDX,
+  loadEntryPoint,
+  createCompiler
+};

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/index.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import {
+  createCompiler,
+  defaultConfig,
+  defaultConfigPath
+} from "../chunk-UDFHC2Y3.js";
+
+// src/cli/index.ts
+import { Cli, Command, Option } from "clipanion";
+
+// src/utils/load-config.ts
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import * as fs from "node:fs";
+async function loadConfig(configFile = defaultConfigPath) {
+  const configPath = path.resolve(configFile);
+  if (!fs.existsSync(configPath))
+    return defaultConfig;
+  const importPath = pathToFileURL(configPath).href;
+  const result = await import(`${importPath}?x=${Date.now()}`);
+  return "default" in result ? result.default : result;
+}
+
+// src/cli/index.ts
+var BuildCommand = class extends Command {
+  static paths = [[`build`]];
+  config = Option.String({ required: false });
+  async execute() {
+    const config = await loadConfig(this.config);
+    const compiler = await createCompiler(config);
+    await compiler.emit();
+    this.context.stdout.write(`Build successful
+`);
+  }
+};
+var WatchCommand = class extends Command {
+  static paths = [[`watch`]];
+  config = Option.String({ required: false });
+  async execute() {
+    const config = await loadConfig(this.config);
+    const compiler = await createCompiler(config);
+    this.context.stdout.write(`Started server
+`);
+    compiler.watch();
+  }
+};
+var [node, app, ...args] = process.argv;
+var cli = new Cli({
+  binaryLabel: `fuma-content-cli`,
+  binaryName: `${node} ${app}`,
+  binaryVersion: `1.0.0`
+});
+cli.register(BuildCommand);
+cli.register(WatchCommand);
+void cli.runExit(args);

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { AnyZodObject, z } from 'zod';
+import { MDXContent } from 'mdx/types';
+
+interface CreateOptions {
+    schema?: AnyZodObject;
+    /**
+     * Filter file paths
+     */
+    include?: string | string[];
+}
+interface Document<Info = unknown> {
+    info: Info;
+    /**
+     * Render data, should be accepted by renderer
+     */
+    renderer: MDXContent;
+    /**
+     * File Path
+     */
+    file: string;
+}
+interface Json<Info = unknown> {
+    info: Info;
+    /**
+     * File Path
+     */
+    file: string;
+}
+type GetInfoType<T extends CreateOptions> = T["schema"] extends AnyZodObject ? z.infer<T["schema"]> : Record<string, unknown>;
+declare function document<T extends CreateOptions>(entryPoint: unknown, options?: T): Document<GetInfoType<T>>[];
+declare function json<T extends CreateOptions>(entryPoint: unknown, options?: T): Json<GetInfoType<T>>[];
+
+export { type CreateOptions, type Document, type Json, document, json };

package/dist/index.js

@@ -0,0 +1,54 @@
+// src/source/index.ts
+import { z } from "zod";
+import micromatch from "micromatch";
+var defaultSchema = z.record(z.string(), z.unknown());
+function document(entryPoint, options) {
+  const { schema = defaultSchema, include } = options ?? {};
+  return read(entryPoint, ["md", "mdx"], include).map((item) => {
+    const {
+      default: render,
+      format: _format,
+      file,
+      frontmatter,
+      ...rest
+    } = item;
+    const result = schema.safeParse(frontmatter);
+    if (!result.success)
+      throw createError(file, result.error);
+    return {
+      file,
+      info: result.data,
+      renderer: render,
+      ...rest
+    };
+  });
+}
+function json(entryPoint, options) {
+  const { schema = defaultSchema, include } = options ?? {};
+  return read(entryPoint, ["json"], include).map(
+    ({ file, default: data }) => {
+      const result = schema.safeParse(data);
+      if (!result.success)
+        throw createError(file, result.error);
+      return {
+        file,
+        info: result.data
+      };
+    }
+  );
+}
+function createError(file, err) {
+  return new Error(
+    `${file}:
+${Object.entries(err.flatten().fieldErrors).map(([k, v]) => `${k}: ${v?.join(", ")}`).join("\n")}`
+  );
+}
+function read(entryPoint, format, include) {
+  const cast = entryPoint;
+  const entries = format.flatMap((f) => cast[f] ?? []);
+  return entries.filter((e) => !include || micromatch.isMatch(e.file, include));
+}
+export {
+  document,
+  json
+};

package/dist/internal.d.ts

@@ -0,0 +1,103 @@
+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 Output {
+    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']`
+     */
+    remarkExports?: string[];
+}
+/**
+ * Load MDX/markdown files
+ */
+declare const loadMDX: ({ lastModifiedTime, format: forceFormat, remarkExports, ...rest }?: Options) => Transformer;
+
+interface OutputEntry extends Output {
+    /**
+     * extension of file, like: `md`
+     */
+    format: string;
+    file: string;
+}
+declare function compile(this: Compiler): Promise<OutputEntry[]>;
+declare function compileFile(this: Compiler, file: string): Promise<OutputEntry>;
+
+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;
+}
+declare function emit(this: Compiler): Promise<void>;
+declare function emitEntry(this: Compiler, 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[];
+    _cache: Map<string, OutputEntry>;
+}
+
+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;
+declare const defaultConfigPath = "./fc.config.js";
+
+export { type CreateCompilerOptions, type EntryPointOptions, type Options, createCompiler, defaultConfig, defaultConfigPath, loadEntryPoint, loadMDX };

package/dist/internal.js

@@ -0,0 +1,14 @@
+import {
+  createCompiler,
+  defaultConfig,
+  defaultConfigPath,
+  loadEntryPoint,
+  loadMDX
+} from "./chunk-UDFHC2Y3.js";
+export {
+  createCompiler,
+  defaultConfig,
+  defaultConfigPath,
+  loadEntryPoint,
+  loadMDX
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "fuma-content",
+  "version": "0.0.0",
+  "description": "Write content for web apps",
+  "keywords": [
+    "Content",
+    "Docs"
+  ],
+  "repository": "github:fuma-nama/fuma-content",
+  "license": "MIT",
+  "type": "module",
+  "bin": "./dist/cli/index.js",
+  "author": "Fuma Nama",
+  "files": [
+    "dist/*"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./internal": {
+      "import": "./dist/internal.js",
+      "types": "./dist/internal.d.ts"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "internal": [
+        "./dist/internal.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@mdx-js/mdx": "^3.0.0",
+    "chokidar": "^3.5.3",
+    "clipanion": "4.0.0-rc.3",
+    "cross-spawn": "^7.0.3",
+    "estree-util-value-to-estree": "^3.0.1",
+    "fast-glob": "^3.3.2",
+    "gray-matter": "^4.0.3",
+    "micromatch": "^4.0.5",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
+    "@types/mdast": "^4.0.3",
+    "@types/mdx": "^2.0.11",
+    "@types/micromatch": "^4.0.6",
+    "typescript": "^5.3.3",
+    "unified": "^11.0.4",
+    "eslint-config": "0.0.0",
+    "typescript-config": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint ."
+  }
+}