mdorigin 0.1.0

package/dist/index-builder.js

@@ -0,0 +1,299 @@
+import { readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { inferDirectoryContentType } from './core/content-type.js';
+import { getDirectoryIndexCandidates } from './core/directory-index.js';
+import { parseMarkdownDocument } from './core/markdown.js';
+const INDEX_START_MARKER = '<!-- INDEX:START -->';
+const INDEX_END_MARKER = '<!-- INDEX:END -->';
+export async function buildDirectoryIndexes(options) {
+    if (!options.rootDir && !options.dir) {
+        throw new Error('Expected either rootDir or dir.');
+    }
+    if (options.rootDir && options.dir) {
+        throw new Error('Use either rootDir or dir, not both.');
+    }
+    if (options.dir) {
+        const directoryPath = path.resolve(options.dir);
+        const updatedFile = await updateSingleDirectoryIndex(directoryPath, {
+            createIfMissing: false,
+        });
+        return {
+            updatedFiles: updatedFile ? [updatedFile] : [],
+            skippedDirectories: updatedFile ? [] : [directoryPath],
+        };
+    }
+    const rootDir = path.resolve(options.rootDir);
+    const directories = await listDirectoriesRecursively(rootDir);
+    const updatedFiles = [];
+    const skippedDirectories = [];
+    for (const directoryPath of directories) {
+        const updatedFile = await updateSingleDirectoryIndex(directoryPath, {
+            createIfMissing: false,
+        });
+        if (updatedFile) {
+            updatedFiles.push(updatedFile);
+            continue;
+        }
+        skippedDirectories.push(directoryPath);
+    }
+    return { updatedFiles, skippedDirectories };
+}
+async function updateSingleDirectoryIndex(directoryPath, options) {
+    const indexFilePath = await resolveDirectoryIndexFile(directoryPath);
+    if (indexFilePath === null && !options.createIfMissing) {
+        return null;
+    }
+    const targetFilePath = indexFilePath ?? path.join(directoryPath, 'index.md');
+    const existingContent = indexFilePath
+        ? await readFile(indexFilePath, 'utf8')
+        : '';
+    const block = await buildManagedIndexBlock(directoryPath);
+    const nextContent = upsertManagedIndexBlock(existingContent, block, {
+        directoryPath,
+    });
+    if (nextContent !== existingContent) {
+        await writeFile(targetFilePath, nextContent, 'utf8');
+    }
+    return targetFilePath;
+}
+export async function buildManagedIndexBlock(directoryPath) {
+    const entries = await readdir(directoryPath, { withFileTypes: true });
+    const directories = [];
+    const articles = [];
+    for (const entry of entries) {
+        if (entry.name.startsWith('.')) {
+            continue;
+        }
+        const fullPath = path.join(directoryPath, entry.name);
+        if (entry.isDirectory()) {
+            const resolvedEntry = await resolveDirectoryEntry(fullPath, entry.name);
+            if (resolvedEntry.draft) {
+                continue;
+            }
+            if (resolvedEntry.type === 'post') {
+                articles.push({
+                    title: resolvedEntry.title,
+                    date: resolvedEntry.date,
+                    summary: resolvedEntry.summary,
+                    link: `./${entry.name}/`,
+                    order: resolvedEntry.order,
+                });
+            }
+            else {
+                directories.push({
+                    title: resolvedEntry.title,
+                    link: `./${entry.name}/`,
+                    order: resolvedEntry.order,
+                });
+            }
+            continue;
+        }
+        if (!entry.isFile() || path.extname(entry.name).toLowerCase() !== '.md') {
+            continue;
+        }
+        if (entry.name === 'index.md' || entry.name === 'README.md') {
+            continue;
+        }
+        const source = await readFile(fullPath, 'utf8');
+        const parsed = await parseMarkdownDocument(entry.name, source);
+        if (parsed.meta.draft === true) {
+            continue;
+        }
+        articles.push({
+            title: parsed.meta.title ?? entry.name.slice(0, -'.md'.length),
+            date: parsed.meta.date,
+            summary: parsed.meta.summary ?? extractFirstParagraph(parsed.body),
+            link: `./${entry.name}`,
+            order: parsed.meta.order,
+        });
+    }
+    directories.sort(compareDirectories);
+    articles.sort(compareArticles);
+    return renderManagedIndexBlock(directories, articles);
+}
+export function upsertManagedIndexBlock(source, block, options = {}) {
+    const hasStart = source.includes(INDEX_START_MARKER);
+    const hasEnd = source.includes(INDEX_END_MARKER);
+    if (hasStart !== hasEnd) {
+        const scope = options.directoryPath ? ` in ${options.directoryPath}` : '';
+        throw new Error(`Found only one index marker${scope}.`);
+    }
+    if (hasStart && hasEnd) {
+        const pattern = new RegExp(`${escapeRegExp(INDEX_START_MARKER)}[\\s\\S]*?${escapeRegExp(INDEX_END_MARKER)}`, 'm');
+        return source.replace(pattern, block);
+    }
+    const trimmed = source.trimEnd();
+    if (trimmed === '') {
+        return `${block}\n`;
+    }
+    return `${trimmed}\n\n${block}\n`;
+}
+function renderManagedIndexBlock(directories, articles) {
+    const lines = [INDEX_START_MARKER, ''];
+    if (directories.length > 0) {
+        for (const entry of directories) {
+            lines.push(`- [${entry.title}](${entry.link})`);
+        }
+        lines.push('');
+    }
+    if (articles.length > 0) {
+        for (const article of articles) {
+            lines.push(`- [${article.title}](${article.link})`);
+            const detail = [article.date, article.summary].filter(Boolean).join(' · ');
+            if (detail !== '') {
+                lines.push(`  ${detail}`);
+            }
+            lines.push('');
+        }
+    }
+    lines.push(INDEX_END_MARKER);
+    return lines.join('\n');
+}
+async function resolveDirectoryEntry(directoryPath, fallbackName) {
+    const indexPath = await resolveDirectoryIndexFile(directoryPath);
+    if (indexPath === null) {
+        return {
+            title: fallbackName,
+            type: 'page',
+            draft: false,
+        };
+    }
+    const source = await readFile(indexPath, 'utf8');
+    const parsed = await parseMarkdownDocument(path.basename(indexPath), source);
+    const shape = await inspectDirectoryShape(directoryPath);
+    return {
+        title: parsed.meta.title ?? fallbackName,
+        type: inferDirectoryContentType(parsed.meta, shape),
+        date: parsed.meta.date,
+        summary: parsed.meta.summary ?? extractFirstParagraph(parsed.body),
+        draft: parsed.meta.draft === true,
+        order: parsed.meta.order,
+    };
+}
+async function listDirectoriesRecursively(rootDir) {
+    const directories = [rootDir];
+    const entries = await readdir(rootDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith('.')) {
+            continue;
+        }
+        directories.push(...(await listDirectoriesRecursively(path.join(rootDir, entry.name))));
+    }
+    return directories;
+}
+async function inspectDirectoryShape(directoryPath) {
+    const entries = await readdir(directoryPath, { withFileTypes: true });
+    let hasChildDirectories = false;
+    let hasExtraMarkdownFiles = false;
+    let hasAssetFiles = false;
+    for (const entry of entries) {
+        if (entry.name.startsWith('.')) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            hasChildDirectories = true;
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        const extension = path.extname(entry.name).toLowerCase();
+        if (extension === '.md') {
+            if (entry.name !== 'index.md' && entry.name !== 'README.md') {
+                hasExtraMarkdownFiles = true;
+            }
+            continue;
+        }
+        hasAssetFiles = true;
+    }
+    return {
+        hasChildDirectories,
+        hasExtraMarkdownFiles,
+        hasAssetFiles,
+    };
+}
+function compareDirectories(left, right) {
+    const orderComparison = compareOptionalOrder(left.order, right.order);
+    if (orderComparison !== 0) {
+        return orderComparison;
+    }
+    return left.title.localeCompare(right.title);
+}
+function compareArticles(left, right) {
+    const orderComparison = compareOptionalOrder(left.order, right.order);
+    if (orderComparison !== 0) {
+        return orderComparison;
+    }
+    const leftTimestamp = left.date ? Date.parse(left.date) : Number.NaN;
+    const rightTimestamp = right.date ? Date.parse(right.date) : Number.NaN;
+    if (!Number.isNaN(leftTimestamp) && !Number.isNaN(rightTimestamp)) {
+        if (leftTimestamp !== rightTimestamp) {
+            return rightTimestamp - leftTimestamp;
+        }
+    }
+    else if (!Number.isNaN(leftTimestamp)) {
+        return -1;
+    }
+    else if (!Number.isNaN(rightTimestamp)) {
+        return 1;
+    }
+    return left.title.localeCompare(right.title);
+}
+function compareOptionalOrder(leftOrder, rightOrder) {
+    if (leftOrder !== undefined && rightOrder !== undefined) {
+        if (leftOrder !== rightOrder) {
+            return leftOrder - rightOrder;
+        }
+        return 0;
+    }
+    if (leftOrder !== undefined) {
+        return -1;
+    }
+    if (rightOrder !== undefined) {
+        return 1;
+    }
+    return 0;
+}
+function extractFirstParagraph(markdown) {
+    const paragraphs = markdown
+        .split(/\n\s*\n/g)
+        .map((paragraph) => paragraph.trim())
+        .filter((paragraph) => paragraph !== '');
+    for (const paragraph of paragraphs) {
+        if (paragraph.startsWith('#') ||
+            paragraph.startsWith('<!--') ||
+            paragraph.startsWith('- ') ||
+            paragraph.startsWith('* ')) {
+            continue;
+        }
+        return paragraph.replace(/\s+/g, ' ');
+    }
+    return undefined;
+}
+async function resolveDirectoryIndexFile(directoryPath) {
+    for (const candidate of getDirectoryIndexCandidates('')) {
+        const candidatePath = path.join(directoryPath, candidate);
+        if (await pathExists(candidatePath)) {
+            return candidatePath;
+        }
+    }
+    return null;
+}
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "mdorigin",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Markdown-first publishing engine with raw Markdown and HTML views.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jolestar/mdorigin.git"
+  },
+  "homepage": "https://github.com/jolestar/mdorigin#readme",
+  "bugs": {
+    "url": "https://github.com/jolestar/mdorigin/issues"
+  },
+  "keywords": [
+    "markdown",
+    "publishing",
+    "static-site",
+    "cloudflare-workers",
+    "cli"
+  ],
+  "bin": {
+    "mdorigin": "./dist/cli/main.js"
+  },
+  "exports": {
+    "./cloudflare": {
+      "types": "./dist/cloudflare.d.ts",
+      "default": "./dist/cloudflare.js"
+    },
+    "./cloudflare-runtime": {
+      "types": "./dist/cloudflare-runtime.d.ts",
+      "default": "./dist/cloudflare-runtime.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli/main.ts dev",
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "build:index": "tsx src/cli/main.ts build index",
+    "build:cloudflare": "tsx src/cli/main.ts build cloudflare",
+    "init:cloudflare": "tsx src/cli/main.ts init cloudflare",
+    "check": "tsc --noEmit -p tsconfig.json",
+    "test": "node --test --import tsx src/*.test.ts src/**/*.test.ts",
+    "prepack": "npm run build",
+    "pack:check": "npm pack --dry-run"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "remark": "^15.0.1",
+    "remark-gfm": "^4.0.1",
+    "remark-html": "^16.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2"
+  }
+}