@jacobbubu/md-to-lark 1.0.0

package/dist/commands/publish-md/pipeline-transform.js

@@ -0,0 +1,4 @@
+export { applyStandaloneAttachmentTransforms } from '../../publish/asset-adapter.js';
+export { patchBTTForMermaidAndAssets } from '../../publish/btt-patch.js';
+export { buildPipelineDocumentId } from '../../publish/ids.js';
+export { applyTableColumnWidthHeuristics, collectMermaidPatches, ensureLastBlockBttIds } from '../../publish/last-normalize.js';

package/dist/commands/publish-md/preset-loader.js

@@ -0,0 +1,113 @@
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { rewriteRelativeMediumAuthorLinks } from './presets/medium.js';
+import { formatChineseMarkdown } from './presets/zh-format.js';
+const BUILTIN_MARKDOWN_PRESETS = Object.freeze({
+    medium: {
+        transform: rewriteRelativeMediumAuthorLinks,
+        aliases: ['medium', 'builtin:medium', 'preset:medium'],
+    },
+    'zh-format': {
+        transform: (markdown, context) => formatChineseMarkdown(markdown, context.inputPath),
+        aliases: [
+            'zh-format',
+            'zh-md-format',
+            'builtin:zh-format',
+            'preset:zh-format',
+            'zh-smart-quotes',
+            'cn-smart-quotes',
+            'builtin:zh-smart-quotes',
+            'preset:zh-smart-quotes',
+        ],
+    },
+});
+function toObjectRecord(value) {
+    return value && typeof value === 'object' ? value : null;
+}
+function pickTransform(moduleExports) {
+    const directCandidates = [
+        moduleExports.default,
+        moduleExports.transformMarkdown,
+        moduleExports.transform,
+        moduleExports.preset,
+    ];
+    for (const candidate of directCandidates) {
+        if (typeof candidate === 'function') {
+            return candidate;
+        }
+        const record = toObjectRecord(candidate);
+        if (!record)
+            continue;
+        if (typeof record.transformMarkdown === 'function') {
+            return record.transformMarkdown;
+        }
+        if (typeof record.transform === 'function') {
+            return record.transform;
+        }
+    }
+    return null;
+}
+function resolveBuiltInPreset(rawPreset) {
+    const normalized = rawPreset.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    for (const [name, preset] of Object.entries(BUILTIN_MARKDOWN_PRESETS)) {
+        if (!preset.aliases.includes(normalized))
+            continue;
+        return {
+            sourcePath: `builtin:${name}`,
+            displayPath: `builtin:${name}`,
+            transform: preset.transform,
+        };
+    }
+    return null;
+}
+export function listBuiltinMarkdownPresetNames() {
+    return Object.keys(BUILTIN_MARKDOWN_PRESETS);
+}
+export async function loadMarkdownPreset(rawPath) {
+    const trimmed = (rawPath ?? '').trim();
+    if (!trimmed)
+        return null;
+    const builtin = resolveBuiltInPreset(trimmed);
+    if (builtin)
+        return builtin;
+    const absolutePath = path.resolve(trimmed);
+    let moduleStat;
+    try {
+        moduleStat = await stat(absolutePath);
+    }
+    catch {
+        const builtins = listBuiltinMarkdownPresetNames()
+            .map((name) => `"${name}"`)
+            .join(', ');
+        throw new Error(`Preset module not found: ${absolutePath}. Built-in presets: ${builtins}`);
+    }
+    if (!moduleStat.isFile()) {
+        throw new Error(`Preset module is not a file: ${absolutePath}`);
+    }
+    let importedModule;
+    try {
+        importedModule = (await import(pathToFileURL(absolutePath).href));
+    }
+    catch (error) {
+        throw new Error(`Failed to import preset module "${absolutePath}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const transform = pickTransform(importedModule);
+    if (!transform) {
+        throw new Error(`Invalid preset module "${absolutePath}". Expected export: default function, transformMarkdown(), transform(), or preset object.`);
+    }
+    const wrappedTransform = async (markdown, context) => {
+        const next = await transform(markdown, context);
+        if (typeof next !== 'string') {
+            throw new Error(`Preset "${absolutePath}" must return a markdown string, got ${next === null ? 'null' : typeof next}.`);
+        }
+        return next;
+    };
+    return {
+        sourcePath: absolutePath,
+        displayPath: path.relative(process.cwd(), absolutePath) || absolutePath,
+        transform: wrappedTransform,
+    };
+}

package/dist/commands/publish-md/presets/medium.js

@@ -0,0 +1,7 @@
+const RELATIVE_MEDIUM_AUTHOR_LINK_RE = /\]\((\/?@[^)\s]+)\)/g;
+export function rewriteRelativeMediumAuthorLinks(markdown) {
+    return markdown.replace(RELATIVE_MEDIUM_AUTHOR_LINK_RE, (_matched, rawPath) => {
+        const normalizedPath = rawPath.startsWith('/') ? rawPath : `/${rawPath}`;
+        return `](https://medium.com${normalizedPath})`;
+    });
+}

package/dist/commands/publish-md/presets/zh-format.js

@@ -0,0 +1,8 @@
+import { prettifyMarkdownContent } from '@jacobbubu/md-zh-format';
+export async function formatChineseMarkdown(markdown, inputPath) {
+    const result = await prettifyMarkdownContent(markdown, inputPath, {
+        preserveFrontmatter: true,
+        promoteHeadings: false,
+    });
+    return result.prettifiedContent;
+}

package/dist/commands/publish-md/title-policy.js

@@ -0,0 +1,93 @@
+import path from 'node:path';
+import { toString } from 'hast-util-to-string';
+function stripMarkdownExtension(filePath) {
+    return filePath.replace(/\.md$/i, '');
+}
+function formatDatePrefix(now) {
+    const year = String(now.getFullYear());
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    return `${year}${month}${day}`;
+}
+function withDatePrefix(title, now = new Date()) {
+    const trimmed = title.trim();
+    const datePrefix = formatDatePrefix(now);
+    if (!trimmed)
+        return `${datePrefix}-untitled`;
+    if (new RegExp(`^${datePrefix}-`).test(trimmed))
+        return trimmed;
+    return `${datePrefix}-${trimmed}`;
+}
+function finalizeTitle(title, datePrefixEnabled) {
+    const trimmed = title.trim();
+    if (datePrefixEnabled) {
+        return withDatePrefix(trimmed);
+    }
+    return trimmed || 'untitled';
+}
+function isElementNode(node) {
+    return node.type === 'element';
+}
+function collectH1Hits(node, out) {
+    const children = Array.isArray(node.children) ? node.children : [];
+    for (let index = 0; index < children.length; index += 1) {
+        const child = children[index];
+        if (!child || !isElementNode(child))
+            continue;
+        if (child.tagName === 'h1') {
+            out.push({ parent: node, index, node: child });
+        }
+        collectH1Hits(child, out);
+    }
+}
+function promoteHeadingsOneLevel(node) {
+    const children = Array.isArray(node.children) ? node.children : [];
+    for (const child of children) {
+        if (!child || !isElementNode(child))
+            continue;
+        const headingMatch = /^h([2-9])$/.exec(child.tagName);
+        if (headingMatch) {
+            const currentLevel = Number(headingMatch[1] ?? 2);
+            child.tagName = `h${currentLevel - 1}`;
+        }
+        promoteHeadingsOneLevel(child);
+    }
+}
+export function applySingleH1TitleRule(hast) {
+    const h1Hits = [];
+    collectH1Hits(hast, h1Hits);
+    if (h1Hits.length !== 1)
+        return {};
+    const onlyHit = h1Hits[0];
+    if (!onlyHit)
+        return {};
+    const rawTitle = toString(onlyHit.node).trim();
+    const parentChildren = Array.isArray(onlyHit.parent.children) ? onlyHit.parent.children : [];
+    if (onlyHit.index >= 0 && onlyHit.index < parentChildren.length) {
+        parentChildren.splice(onlyHit.index, 1);
+    }
+    promoteHeadingsOneLevel(hast);
+    return rawTitle ? { derivedTitle: rawTitle } : {};
+}
+export function buildTitleForMarkdown(markdownPath, inputSet, titleOverride, h1DerivedTitle, options) {
+    const datePrefixEnabled = options?.datePrefix ?? true;
+    if (inputSet.mode === 'single') {
+        if (titleOverride && titleOverride.trim()) {
+            return finalizeTitle(titleOverride, datePrefixEnabled);
+        }
+        if (h1DerivedTitle && h1DerivedTitle.trim()) {
+            return finalizeTitle(h1DerivedTitle, datePrefixEnabled);
+        }
+        const baseName = path.basename(markdownPath, path.extname(markdownPath));
+        return finalizeTitle(baseName || 'md-to-lark', datePrefixEnabled);
+    }
+    const relative = stripMarkdownExtension(path.relative(inputSet.rootPath, markdownPath));
+    const relativeTitle = relative.split(path.sep).join(' / ');
+    if (titleOverride && titleOverride.trim()) {
+        return finalizeTitle(`${titleOverride.trim()} / ${relativeTitle}`, datePrefixEnabled);
+    }
+    if (h1DerivedTitle && h1DerivedTitle.trim()) {
+        return finalizeTitle(h1DerivedTitle, datePrefixEnabled);
+    }
+    return finalizeTitle(relativeTitle || path.basename(markdownPath, path.extname(markdownPath)), datePrefixEnabled);
+}

package/dist/index.js

@@ -0,0 +1 @@
+export { publishMdToLark } from './commands/publish-md/index.js';

package/dist/interop/btt-to-last.js

@@ -0,0 +1,79 @@
+import { buildLASTIndexes, flattenTreeBlocks, fromRawBlockToLAST, } from './codec-btt-to-last.js';
+import { normalizeDocumentIdToLAST } from './codec-last-to-btt.js';
+export function convertBTTToLAST(bttDoc) {
+    const rawBlocks = Object.keys(bttDoc.flatBlocks ?? {}).length
+        ? Object.values(bttDoc.flatBlocks)
+        : flattenTreeBlocks(bttDoc.root);
+    const rawById = new Map();
+    for (const rawBlock of rawBlocks) {
+        rawById.set(String(rawBlock.block_id), rawBlock);
+    }
+    const rootRawId = String(bttDoc.rootBlockId || bttDoc.root.blockId);
+    if (!rawById.has(rootRawId)) {
+        throw new Error(`BTT root block "${rootRawId}" is not found in source blocks.`);
+    }
+    const orderedRawIds = [];
+    const visitedRawIds = new Set();
+    const visitRawId = (rawId) => {
+        if (visitedRawIds.has(rawId))
+            return;
+        const rawBlock = rawById.get(rawId);
+        if (!rawBlock)
+            return;
+        visitedRawIds.add(rawId);
+        orderedRawIds.push(rawId);
+        for (const childId of rawBlock.children ?? []) {
+            visitRawId(String(childId));
+        }
+    };
+    visitRawId(rootRawId);
+    for (const rawBlock of rawBlocks) {
+        const rawId = String(rawBlock.block_id);
+        if (!visitedRawIds.has(rawId)) {
+            orderedRawIds.push(rawId);
+        }
+    }
+    const bttToLastBlockId = {};
+    let blockCounter = 1;
+    for (const rawId of orderedRawIds) {
+        bttToLastBlockId[rawId] = `b_${blockCounter}`;
+        blockCounter += 1;
+    }
+    const inlineCounter = { value: 1 };
+    const blocks = {};
+    for (const rawId of orderedRawIds) {
+        const rawBlock = rawById.get(rawId);
+        if (!rawBlock)
+            continue;
+        const block = fromRawBlockToLAST(rawBlock, inlineCounter, bttToLastBlockId);
+        blocks[block.id] = block;
+    }
+    const rootId = bttToLastBlockId[rootRawId];
+    if (!rootId) {
+        throw new Error(`Failed to map root block "${rootRawId}" to LAST id.`);
+    }
+    if (!blocks[rootId]) {
+        throw new Error(`BTT rootBlockId "${rootId}" is not found in blocks.`);
+    }
+    const doc = {
+        schema: 'LAST',
+        version: '1.0.0',
+        id: normalizeDocumentIdToLAST(String(bttDoc.documentId)),
+        rootId,
+        blocks,
+        indexes: {
+            byType: {},
+            textScopes: {},
+            textScopeByBlockId: {},
+        },
+    };
+    doc.indexes = buildLASTIndexes(doc);
+    return doc;
+}
+export function summarizeBTTDocument(bttDoc) {
+    return {
+        totalBlocks: bttDoc.totalBlocks,
+        rootBlockId: bttDoc.rootBlockId,
+        missingChildren: bttDoc.missingChildren.length,
+    };
+}