feishu-md-sync 0.1.0

package/dist/markdown/blocks.js

@@ -0,0 +1,305 @@
+import { normalizeMarkdownLinkUrl } from './links.js';
+const BLOCK_TYPES = {
+    text: 2,
+    heading1: 3,
+    heading2: 4,
+    heading3: 5,
+    heading4: 6,
+    heading5: 7,
+    heading6: 8,
+    bullet: 12,
+    ordered: 13,
+    code: 14,
+    table: 31
+};
+export const LANG_IDS = {
+    plaintext: 1,
+    text: 1,
+    bash: 7,
+    shell: 62,
+    sh: 62,
+    cpp: 9,
+    c: 10,
+    go: 22,
+    golang: 22,
+    json: 28,
+    java: 29,
+    javascript: 30,
+    js: 30,
+    nodejs: 30,
+    node: 30,
+    markdown: 40,
+    python: 49,
+    py: 49,
+    restful: 7,
+    rest: 7,
+    sql: 57,
+    typescript: 64,
+    ts: 64,
+    yaml: 67,
+    yml: 67
+};
+export function languageIdForMarkdownLanguage(language) {
+    return LANG_IDS[language.toLowerCase()] ?? LANG_IDS.plaintext;
+}
+export function markdownToFeishuBlocks(markdown) {
+    const lines = markdown.replace(/\r\n/g, '\n').split('\n');
+    const blocks = [];
+    for (let index = 0; index < lines.length;) {
+        const line = lines[index] ?? '';
+        if (line.trim() === '') {
+            index += 1;
+            continue;
+        }
+        const fence = line.match(/^```(\S*)\s*$/);
+        if (fence) {
+            const lang = fence[1] || 'plaintext';
+            const codeLines = [];
+            index += 1;
+            while (index < lines.length && !/^```\s*$/.test(lines[index] ?? '')) {
+                codeLines.push(lines[index] ?? '');
+                index += 1;
+            }
+            if (index < lines.length)
+                index += 1;
+            blocks.push(codeBlock(codeLines.join('\n'), lang));
+            continue;
+        }
+        if (isTableStart(lines, index)) {
+            const tableLines = [];
+            while (index < lines.length && /^\s*\|.*\|\s*$/.test(lines[index] ?? '')) {
+                tableLines.push(lines[index] ?? '');
+                index += 1;
+            }
+            blocks.push(tableBlock(tableLines));
+            continue;
+        }
+        const heading = line.match(/^(#{1,6})\s+(.+)$/);
+        if (heading) {
+            blocks.push(headingBlock(heading[1].length, stripHeadingAnchor(heading[2])));
+            index += 1;
+            continue;
+        }
+        const listMarker = parseListMarker(line);
+        if (listMarker) {
+            while (index < lines.length) {
+                const item = parseListMarker(lines[index] ?? '');
+                if (!item)
+                    break;
+                index += 1;
+                const childLines = [];
+                while (index < lines.length) {
+                    const childLine = lines[index] ?? '';
+                    if (childLine.trim() === '')
+                        break;
+                    if (parseListMarker(childLine))
+                        break;
+                    if (/^(#{1,6})\s+/.test(childLine) || /^```/.test(childLine) || isTableStart(lines, index))
+                        break;
+                    childLines.push(childLine.trim());
+                    index += 1;
+                }
+                blocks.push(listBlock(item.text, item.ordered, childLines.map((childLine) => textBlock(childLine))));
+            }
+            continue;
+        }
+        const paragraphLines = [line.trim()];
+        index += 1;
+        while (index < lines.length &&
+            lines[index]?.trim() !== '' &&
+            !/^(#{1,6})\s+/.test(lines[index] ?? '') &&
+            !/^```/.test(lines[index] ?? '') &&
+            !parseListMarker(lines[index] ?? '') &&
+            !isTableStart(lines, index)) {
+            paragraphLines.push((lines[index] ?? '').trim());
+            index += 1;
+        }
+        blocks.push(textBlock(paragraphLines.join(' ')));
+    }
+    return blocks;
+}
+function textElement(content, style = {}) {
+    return {
+        text_run: {
+            content,
+            text_element_style: {
+                bold: false,
+                italic: false,
+                strikethrough: false,
+                underline: false,
+                inline_code: false,
+                ...style
+            }
+        }
+    };
+}
+export function parseInlineText(text) {
+    const elements = [];
+    let cursor = 0;
+    const pattern = /(==[^=]+==|`[^`]+`|\*\*[^*]+\*\*|\*[^*\n]+\*|\[[^\]]+\]\([^)]+\))/g;
+    for (const match of text.matchAll(pattern)) {
+        const start = match.index ?? 0;
+        if (start > cursor) {
+            elements.push(textElement(text.slice(cursor, start)));
+        }
+        const token = match[0];
+        if (token.startsWith('==')) {
+            elements.push(textElement(token.slice(2, -2), { background_color: 5 }));
+        }
+        else if (token.startsWith('`')) {
+            elements.push(textElement(token.slice(1, -1), { inline_code: true }));
+        }
+        else if (token.startsWith('**')) {
+            elements.push(textElement(token.slice(2, -2), { bold: true }));
+        }
+        else if (token.startsWith('*')) {
+            elements.push(textElement(token.slice(1, -1), { italic: true }));
+        }
+        else {
+            const link = token.match(/^\[([^\]]+)\]\(([^)]+)\)$/);
+            if (link) {
+                elements.push(textElement(link[1], { link: { url: normalizeMarkdownLinkUrl(link[2]) } }));
+            }
+        }
+        cursor = start + token.length;
+    }
+    if (cursor < text.length) {
+        elements.push(textElement(text.slice(cursor)));
+    }
+    return elements.length > 0 ? elements : [textElement('')];
+}
+function textBlock(text, style = {}) {
+    return {
+        block_type: BLOCK_TYPES.text,
+        text: {
+            elements: parseInlineText(text).map((element) => {
+                if (!element.text_run)
+                    return element;
+                return {
+                    ...element,
+                    text_run: {
+                        ...element.text_run,
+                        text_element_style: {
+                            ...element.text_run.text_element_style,
+                            ...style
+                        }
+                    }
+                };
+            }),
+            style: { align: 1 }
+        }
+    };
+}
+function headingBlock(level, text) {
+    const safeLevel = Math.min(Math.max(level, 1), 6);
+    return {
+        block_type: BLOCK_TYPES[`heading${safeLevel}`],
+        [`heading${safeLevel}`]: {
+            elements: parseInlineText(text),
+            style: { align: 1 }
+        }
+    };
+}
+function listBlock(text, ordered, children = []) {
+    const key = ordered ? 'ordered' : 'bullet';
+    const block = {
+        block_type: ordered ? BLOCK_TYPES.ordered : BLOCK_TYPES.bullet,
+        [key]: {
+            elements: parseInlineText(text),
+            style: {}
+        }
+    };
+    if (children.length > 0)
+        block.children = children;
+    return block;
+}
+function codeBlock(text, lang) {
+    return {
+        block_type: BLOCK_TYPES.code,
+        code: {
+            elements: [textElement(text)],
+            style: {
+                language: languageIdForMarkdownLanguage(lang)
+            }
+        }
+    };
+}
+function parseListMarker(line) {
+    const bullet = line.match(/^\s*[-*]\s+(.+)$/);
+    if (bullet)
+        return { ordered: false, text: bullet[1].trim() };
+    const ordered = line.match(/^\s*\d+[.)]\s+(.+)$/);
+    if (ordered)
+        return { ordered: true, text: ordered[1].trim() };
+    return null;
+}
+function stripHeadingAnchor(text) {
+    return text.trim().replace(/\s*\{#[A-Za-z0-9_-]+\}\s*$/, '').trim();
+}
+function isTableStart(lines, index) {
+    return (/^\s*\|.*\|\s*$/.test(lines[index] ?? '') &&
+        /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(lines[index + 1] ?? ''));
+}
+function tableBlock(lines) {
+    const dataRows = lines.filter((_, index) => index !== 1).map(parseTableRow);
+    const rowSize = dataRows.length;
+    const columnSize = Math.max(...dataRows.map((row) => row.length));
+    const cells = dataRows.flatMap((row) => {
+        return Array.from({ length: columnSize }, (_, index) => textBlock(row[index] ?? '', row === dataRows[0] ? { bold: true } : {}));
+    });
+    return {
+        block_type: BLOCK_TYPES.table,
+        table: {
+            property: {
+                row_size: rowSize,
+                column_size: columnSize,
+                merge_info: Array.from({ length: rowSize * columnSize }, () => null)
+            },
+            cells
+        }
+    };
+}
+function parseTableRow(line) {
+    const trimmed = line.trim();
+    const content = trimmed.startsWith('|') ? trimmed.slice(1) : trimmed;
+    const withoutTrailingPipe = hasUnescapedTrailingPipe(content) ? content.slice(0, -1) : content;
+    const cells = [];
+    let current = '';
+    let inCode = false;
+    let escaping = false;
+    for (const char of withoutTrailingPipe) {
+        if (escaping) {
+            current += char;
+            escaping = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaping = true;
+            continue;
+        }
+        if (char === '`') {
+            inCode = !inCode;
+            current += char;
+            continue;
+        }
+        if (char === '|' && !inCode) {
+            cells.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    if (escaping)
+        current += '\\';
+    cells.push(current.trim());
+    return cells;
+}
+function hasUnescapedTrailingPipe(value) {
+    if (!value.endsWith('|'))
+        return false;
+    let backslashCount = 0;
+    for (let index = value.length - 2; index >= 0 && value[index] === '\\'; index -= 1) {
+        backslashCount += 1;
+    }
+    return backslashCount % 2 === 0;
+}

package/dist/markdown/from-blocks.d.ts

@@ -0,0 +1,2 @@
+import type { FeishuBlock } from '../feishu/types.js';
+export declare function feishuBlocksToMarkdown(blocks: FeishuBlock[]): string;

package/dist/markdown/from-blocks.js

@@ -0,0 +1,110 @@
+import { normalizeMarkdownLinkUrl } from './links.js';
+const LANGUAGE_BY_ID = {
+    7: 'bash',
+    9: 'cpp',
+    22: 'go',
+    28: 'json',
+    29: 'java',
+    30: 'javascript',
+    40: 'markdown',
+    49: 'python',
+    50: 'python',
+    57: 'sql',
+    64: 'typescript',
+    67: 'yaml'
+};
+export function feishuBlocksToMarkdown(blocks) {
+    const parts = blocks.map(renderBlock).filter((part) => part.trim() !== '');
+    return parts.length > 0 ? `${parts.join('\n\n')}\n` : '';
+}
+function renderBlock(block) {
+    if (block.block_type >= 3 && block.block_type <= 8) {
+        const level = block.block_type - 2;
+        const heading = block[`heading${level}`];
+        return `${'#'.repeat(level)} ${renderElements(heading?.elements)}`;
+    }
+    if (block.block_type === 2) {
+        return renderElements(block.text?.elements);
+    }
+    if (block.block_type === 12) {
+        return `- ${renderElements(block.bullet?.elements)}`;
+    }
+    if (block.block_type === 13) {
+        return `1. ${renderElements(block.ordered?.elements)}`;
+    }
+    if (block.block_type === 14) {
+        const code = block.code;
+        const lang = code?.style?.language ? LANGUAGE_BY_ID[code.style.language] ?? '' : '';
+        return `\`\`\`${lang}\n${renderElements(code?.elements)}\n\`\`\``;
+    }
+    if (block.block_type === 31) {
+        return renderTable(block);
+    }
+    if (block.block_type === 19) {
+        return renderCallout(block);
+    }
+    if (block.block_type === 49) {
+        return renderSourceSynced(block);
+    }
+    return `<!-- unsupported Feishu block_type ${block.block_type} omitted by pull -->`;
+}
+function renderSourceSynced(block) {
+    const children = Array.isArray(block.children) ? block.children.filter(isBlock) : [];
+    return children.map(renderBlock).filter((part) => part.trim() !== '').join('\n\n');
+}
+function renderElements(elements = []) {
+    return elements.map((element) => {
+        const run = element.text_run;
+        if (!run) {
+            return renderNonTextElement(element);
+        }
+        const style = run.text_element_style ?? {};
+        let text = run.content;
+        if (style.inline_code)
+            text = `\`${text}\``;
+        if (style.bold)
+            text = `**${text}**`;
+        if (style.link?.url)
+            text = `[${text}](${normalizeMarkdownLinkUrl(style.link.url)})`;
+        return text;
+    }).join('');
+}
+function renderNonTextElement(element) {
+    const mentionDoc = element.mention_doc;
+    if (mentionDoc?.title && mentionDoc.url) {
+        return `[${mentionDoc.title}](${mentionDoc.url})`;
+    }
+    if (mentionDoc?.title) {
+        return mentionDoc.title;
+    }
+    return '';
+}
+function renderTable(block) {
+    const table = block.table;
+    const rows = table?.property?.row_size ?? 0;
+    const cols = table?.property?.column_size ?? 0;
+    const cells = table?.cells ?? [];
+    if (rows === 0 || cols === 0)
+        return '';
+    const renderedRows = Array.from({ length: rows }, (_, row) => {
+        const values = Array.from({ length: cols }, (_, col) => renderBlock(cells[row * cols + col] ?? { block_type: 2 }));
+        return `| ${values.join(' | ')} |`;
+    });
+    const separator = `| ${Array.from({ length: cols }, () => '---').join(' | ')} |`;
+    return [renderedRows[0], separator, ...renderedRows.slice(1)].join('\n');
+}
+function renderCallout(block) {
+    const children = Array.isArray(block.children) ? block.children.filter(isBlock) : [];
+    const rendered = children.map(renderBlock).filter((part) => part.trim() !== '');
+    const body = dropCalloutTitle(rendered).join('\n\n');
+    return body ? `:::note\n${body}\n:::` : ':::note\n:::';
+}
+function dropCalloutTitle(rendered) {
+    if (rendered.length > 1 && /^notes?$/i.test(rendered[0]?.trim() ?? '')) {
+        return rendered.slice(1);
+    }
+    return rendered;
+}
+function isBlock(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value) && 'block_type' in value);
+}

package/dist/markdown/links.d.ts

@@ -0,0 +1,3 @@
+import type { FeishuBlock } from '../feishu/types.js';
+export declare function normalizeMarkdownLinkUrl(url: string): string;
+export declare function normalizeFeishuBlockLinkUrls(blocks: FeishuBlock[]): FeishuBlock[];

package/dist/markdown/links.js

@@ -0,0 +1,44 @@
+export function normalizeMarkdownLinkUrl(url) {
+    if (isAbsoluteHttpUrl(url))
+        return url;
+    let decoded;
+    try {
+        decoded = decodeURIComponent(url);
+    }
+    catch {
+        return url;
+    }
+    return isAbsoluteHttpUrl(decoded) ? decoded : url;
+}
+export function normalizeFeishuBlockLinkUrls(blocks) {
+    return normalizeValue(blocks);
+}
+function normalizeValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(normalizeValue);
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    const normalized = {};
+    for (const [key, child] of Object.entries(value)) {
+        normalized[key] = key === 'url' && typeof child === 'string'
+            ? normalizeMarkdownLinkUrl(child)
+            : normalizeValue(child);
+    }
+    return normalized;
+}
+function isAbsoluteHttpUrl(url) {
+    if (!/^https?:\/\//i.test(url))
+        return false;
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}

package/dist/merge/line-merge.d.ts

@@ -0,0 +1,21 @@
+export type MergeState = 'clean' | 'merged' | 'conflict';
+export type LineMergeResult = {
+    markdown: string;
+    state: MergeState;
+    conflicts: number;
+    changed: boolean;
+};
+export type LineChange = {
+    baseStart: number;
+    baseEnd: number;
+    lines: string[];
+};
+export declare function mergeLines(input: {
+    base: string;
+    local: string;
+    remote: string;
+}): LineMergeResult;
+export declare function mergeWithoutBase(input: {
+    local: string;
+    remote: string;
+}): LineMergeResult;