@md-meta-view/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { collectFrontmatterKeys, parseDirectory, parseMdFile, } from "./parser.js";
+export { loadSettings } from "./settings.js";
+export type { MdData, MdEntry, Settings } from "./types.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { collectFrontmatterKeys, parseDirectory, parseMdFile, } from "./parser.js";
+export { loadSettings } from "./settings.js";

package/dist/parser.d.ts

@@ -0,0 +1,4 @@
+import type { MdEntry, Settings } from "./types.js";
+export declare function parseMdFile(filePath: string, baseDir: string, settings: Settings): Promise<MdEntry>;
+export declare function parseDirectory(dir: string, settings?: Settings): Promise<MdEntry[]>;
+export declare function collectFrontmatterKeys(entries: MdEntry[]): string[];

package/dist/parser.js

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import path from "node:path";
+import matter from "gray-matter";
+import picomatch from "picomatch";
+import rehypeHighlight from "rehype-highlight";
+import rehypeSanitize from "rehype-sanitize";
+import rehypeStringify from "rehype-stringify";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { unified } from "unified";
+const MAX_DEPTH = 5;
+const markdownProcessor = unified()
+    .use(remarkParse)
+    .use(remarkGfm)
+    .use(remarkRehype)
+    .use(rehypeSanitize)
+    .use(rehypeHighlight)
+    .use(rehypeStringify);
+function collectMdFiles(dir, baseDir, depth) {
+    if (depth > MAX_DEPTH)
+        return [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory() &&
+            !entry.name.startsWith(".") &&
+            entry.name !== "node_modules") {
+            files.push(...collectMdFiles(fullPath, baseDir, depth + 1));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".md")) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+export async function parseMdFile(filePath, baseDir, settings) {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const { data, content } = matter(raw);
+    const result = await markdownProcessor.process(content);
+    const relativePath = path.relative(baseDir, filePath);
+    const id = settings.idField && data[settings.idField] != null
+        ? String(data[settings.idField])
+        : relativePath;
+    return {
+        id,
+        filename: path.basename(filePath),
+        relativePath,
+        frontmatter: data,
+        html: String(result),
+    };
+}
+export async function parseDirectory(dir, settings = {}) {
+    const absDir = path.resolve(dir);
+    let files = collectMdFiles(absDir, absDir, 0);
+    if (settings.exclude && settings.exclude.length > 0) {
+        const isExcluded = picomatch(settings.exclude);
+        files = files.filter((f) => {
+            const rel = path.relative(absDir, f);
+            return !isExcluded(rel);
+        });
+    }
+    const entries = await Promise.all(files.map((f) => parseMdFile(f, absDir, settings)));
+    return entries;
+}
+export function collectFrontmatterKeys(entries) {
+    const keys = new Set();
+    for (const entry of entries) {
+        for (const key of Object.keys(entry.frontmatter)) {
+            keys.add(key);
+        }
+    }
+    return Array.from(keys);
+}

package/dist/parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/parser.test.js

@@ -0,0 +1,92 @@
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { collectFrontmatterKeys, parseDirectory, parseMdFile } from "./parser.js";
+const fixturesDir = path.resolve(import.meta.dirname, "../fixtures");
+describe("parseMdFile", () => {
+    it("extracts frontmatter and renders HTML", async () => {
+        const filePath = path.join(fixturesDir, "basic.md");
+        const entry = await parseMdFile(filePath, fixturesDir, {});
+        expect(entry.filename).toBe("basic.md");
+        expect(entry.relativePath).toBe("basic.md");
+        expect(entry.frontmatter.title).toBe("Test Document");
+        expect(entry.frontmatter.date).toEqual(new Date("2026-01-15"));
+        expect(entry.frontmatter.category).toBe("testing");
+        expect(entry.frontmatter.tags).toEqual(["unit", "integration"]);
+        expect(entry.html).toContain("<h1>");
+        expect(entry.html).toContain("Test Document");
+    });
+    it("uses idField from settings when available", async () => {
+        const filePath = path.join(fixturesDir, "basic.md");
+        const entry = await parseMdFile(filePath, fixturesDir, { idField: "number" });
+        expect(entry.id).toBe("001");
+    });
+    it("falls back to relativePath when idField is not set", async () => {
+        const filePath = path.join(fixturesDir, "basic.md");
+        const entry = await parseMdFile(filePath, fixturesDir, {});
+        expect(entry.id).toBe("basic.md");
+    });
+    it("falls back to relativePath when idField is missing from frontmatter", async () => {
+        const filePath = path.join(fixturesDir, "no-frontmatter.md");
+        const entry = await parseMdFile(filePath, fixturesDir, { idField: "number" });
+        expect(entry.id).toBe("no-frontmatter.md");
+    });
+    it("handles files without frontmatter", async () => {
+        const filePath = path.join(fixturesDir, "no-frontmatter.md");
+        const entry = await parseMdFile(filePath, fixturesDir, {});
+        expect(entry.frontmatter).toEqual({});
+        expect(entry.html).toContain("No Frontmatter");
+    });
+    it("resolves relativePath for nested files", async () => {
+        const filePath = path.join(fixturesDir, "sub/nested.md");
+        const entry = await parseMdFile(filePath, fixturesDir, {});
+        expect(entry.relativePath).toBe(path.join("sub", "nested.md"));
+    });
+});
+describe("parseDirectory", () => {
+    it("finds all markdown files recursively", async () => {
+        const entries = await parseDirectory(fixturesDir);
+        const filenames = entries.map((e) => e.filename).sort();
+        expect(filenames).toContain("basic.md");
+        expect(filenames).toContain("nested.md");
+        expect(filenames).toContain("no-frontmatter.md");
+        expect(filenames).toContain("excluded.md");
+    });
+    it("applies exclude patterns from settings", async () => {
+        const entries = await parseDirectory(fixturesDir, { exclude: ["excluded.md"] });
+        const filenames = entries.map((e) => e.filename);
+        expect(filenames).not.toContain("excluded.md");
+        expect(filenames).toContain("basic.md");
+    });
+    it("applies glob exclude patterns for subdirectories", async () => {
+        const entries = await parseDirectory(fixturesDir, { exclude: ["sub/**"] });
+        const filenames = entries.map((e) => e.filename);
+        expect(filenames).not.toContain("nested.md");
+        expect(filenames).toContain("basic.md");
+    });
+    it("uses idField for all entries", async () => {
+        const entries = await parseDirectory(fixturesDir, { idField: "number" });
+        const basic = entries.find((e) => e.filename === "basic.md");
+        const nested = entries.find((e) => e.filename === "nested.md");
+        const noFm = entries.find((e) => e.filename === "no-frontmatter.md");
+        expect(basic?.id).toBe("001");
+        expect(nested?.id).toBe("002");
+        expect(noFm?.id).toBe("no-frontmatter.md");
+    });
+});
+describe("collectFrontmatterKeys", () => {
+    it("collects unique keys from all entries", async () => {
+        const entries = await parseDirectory(fixturesDir);
+        const keys = collectFrontmatterKeys(entries);
+        expect(keys).toContain("title");
+        expect(keys).toContain("date");
+        expect(keys).toContain("category");
+        expect(keys).toContain("tags");
+        expect(keys).toContain("number");
+    });
+    it("returns empty array for entries without frontmatter", () => {
+        const keys = collectFrontmatterKeys([
+            { id: "1", filename: "a.md", relativePath: "a.md", frontmatter: {}, html: "" },
+        ]);
+        expect(keys).toEqual([]);
+    });
+});

package/dist/settings.d.ts

@@ -0,0 +1,2 @@
+import type { Settings } from "./types.js";
+export declare function loadSettings(dir: string): Settings;

package/dist/settings.js

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import path from "node:path";
+const SETTINGS_FILE = "md-meta-view-setting.json";
+export function loadSettings(dir) {
+    const filePath = path.resolve(dir, SETTINGS_FILE);
+    if (!fs.existsSync(filePath))
+        return {};
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        console.warn(`Warning: Failed to parse ${SETTINGS_FILE}: ${e.message}`);
+        return {};
+    }
+}

package/dist/settings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/settings.test.js

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { loadSettings } from "./settings.js";
+const fixturesDir = path.resolve(import.meta.dirname, "../fixtures");
+describe("loadSettings", () => {
+    it("loads settings from md-meta-view-setting.json", () => {
+        const settings = loadSettings(fixturesDir);
+        expect(settings.idField).toBe("number");
+        expect(settings.exclude).toEqual(["excluded.md"]);
+    });
+    it("returns empty object when file does not exist", () => {
+        const settings = loadSettings("/nonexistent/path");
+        expect(settings).toEqual({});
+    });
+    describe("with invalid JSON", () => {
+        let tmpDir;
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "md-meta-view-test-"));
+            fs.writeFileSync(path.join(tmpDir, "md-meta-view-setting.json"), "{ invalid json");
+        });
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true });
+        });
+        it("returns empty object and warns on invalid JSON", () => {
+            const settings = loadSettings(tmpDir);
+            expect(settings).toEqual({});
+        });
+    });
+});

package/dist/types.d.ts

@@ -0,0 +1,16 @@
+export interface MdEntry {
+    id: string;
+    filename: string;
+    relativePath: string;
+    frontmatter: Record<string, unknown>;
+    html: string;
+}
+export interface Settings {
+    idField?: string;
+    exclude?: string[];
+}
+export interface MdData {
+    entries: MdEntry[];
+    keys: string[];
+    settings: Settings;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@md-meta-view/core",
+  "version": "0.1.0",
+  "description": "Core types and markdown parser for md-meta-view",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ShuntaToda/md-meta-view.git",
+    "directory": "packages/core"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "picomatch": "^4.0.4",
+    "unified": "^11.0.5",
+    "remark-parse": "^11.0.0",
+    "remark-gfm": "^4.0.1",
+    "remark-rehype": "^11.1.2",
+    "rehype-sanitize": "^6.0.0",
+    "rehype-highlight": "^7.0.2",
+    "rehype-stringify": "^10.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.0",
+    "@types/picomatch": "^4.0.2",
+    "typescript": "~5.9.3"
+  }
+}