@mnemosyne_os/affine-reader 0.1.0

package/dist/vendor/affine/delta-to-md/delta-to-md.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deltaToMd = void 0;
+// oxlint-disable
+// @ts-nocheck
+const node_1 = require("./utils/node");
+const deltaToMd = (delta, converters) => {
+    return convert(delta, converters).render().trimEnd() + '\n';
+};
+exports.deltaToMd = deltaToMd;
+function convert(ops, converters) {
+    let group, line, el, activeInline, beginningOfLine;
+    let root = new node_1.Node();
+    function newLine() {
+        el = line = new node_1.Node(['', '\n']);
+        root.append(line);
+        activeInline = {};
+    }
+    newLine();
+    for (let i = 0; i < ops.length; i++) {
+        let op = ops[i];
+        if (typeof op.insert === 'object') {
+            for (let k in op.insert) {
+                if (converters.embed[k]) {
+                    applyInlineAttributes(op.attributes);
+                    converters.embed[k].call(el, op.insert[k], op.attributes);
+                }
+            }
+        }
+        else {
+            let lines = op.insert.split('\n');
+            if (hasBlockLevelAttribute(op.attributes, converters)) {
+                // Some line-level styling (ie headings) is applied by inserting a \n
+                // with the style; the style applies back to the previous \n.
+                // There *should* only be one style in an insert operation.
+                for (let j = 1; j < lines.length; j++) {
+                    for (let attr in op.attributes) {
+                        if (converters.block[attr]) {
+                            let fn = converters.block[attr];
+                            if (typeof fn === 'object') {
+                                if (group && group.type !== attr) {
+                                    group = null;
+                                }
+                                if (!group && fn.group) {
+                                    group = {
+                                        el: fn.group(),
+                                        type: attr,
+                                        value: op.attributes[attr],
+                                        distance: 0,
+                                    };
+                                    root.append(group.el);
+                                }
+                                if (group) {
+                                    group.el.append(line);
+                                    group.distance = 0;
+                                }
+                                fn = fn.line;
+                            }
+                            fn.call(line, op.attributes, group);
+                            newLine();
+                            break;
+                        }
+                    }
+                }
+                beginningOfLine = true;
+            }
+            else {
+                for (let l = 0; l < lines.length; l++) {
+                    if ((l > 0 || beginningOfLine) && group && ++group.distance >= 2) {
+                        group = null;
+                    }
+                    applyInlineAttributes(op.attributes, ops[i + 1] && ops[i + 1].attributes);
+                    el.append(lines[l]);
+                    if (l < lines.length - 1) {
+                        newLine();
+                    }
+                }
+                beginningOfLine = false;
+            }
+        }
+    }
+    return root;
+    function applyInlineAttributes(attrs, next) {
+        let first = [];
+        let then = [];
+        attrs = attrs || {};
+        let tag = el, seen = {};
+        while (tag._format) {
+            seen[tag._format] = true;
+            if (!attrs[tag._format] || tag.open !== tag.close) {
+                for (let k in seen) {
+                    delete activeInline[k];
+                }
+                el = tag.parent();
+            }
+            tag = tag.parent();
+        }
+        for (let attr in attrs) {
+            if (converters.inline[attr] && attrs[attr]) {
+                if (activeInline[attr] && activeInline[attr] === attrs[attr]) {
+                    continue; // do nothing -- we should already be inside this style's tag
+                }
+                if (next && attrs[attr] === next[attr]) {
+                    first.push(attr); // if the next operation has the same style, this should be the outermost tag
+                }
+                else {
+                    then.push(attr);
+                }
+                activeInline[attr] = attrs[attr];
+            }
+        }
+        first.forEach(apply);
+        then.forEach(apply);
+        function apply(fmt) {
+            let newEl = converters.inline[fmt].call(null, attrs[fmt]);
+            if (Array.isArray(newEl)) {
+                newEl = new node_1.Node(newEl);
+            }
+            newEl._format = fmt;
+            el.append(newEl);
+            el = newEl;
+        }
+    }
+}
+function hasBlockLevelAttribute(attrs, converters) {
+    for (let k in attrs) {
+        if (Object.keys(converters.block).includes(k)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/vendor/affine/delta-to-md/index.d.ts

@@ -0,0 +1,2 @@
+export { getConverters } from './delta-converters';
+export { deltaToMd } from './delta-to-md';

package/dist/vendor/affine/delta-to-md/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deltaToMd = exports.getConverters = void 0;
+var delta_converters_1 = require("./delta-converters");
+Object.defineProperty(exports, "getConverters", { enumerable: true, get: function () { return delta_converters_1.getConverters; } });
+var delta_to_md_1 = require("./delta-to-md");
+Object.defineProperty(exports, "deltaToMd", { enumerable: true, get: function () { return delta_to_md_1.deltaToMd; } });

package/dist/vendor/affine/delta-to-md/utils/node.d.ts

@@ -0,0 +1,13 @@
+export declare class Node {
+    id: number;
+    children: Node[];
+    open: string;
+    close: string;
+    text: string;
+    _format: string;
+    _parent: Node;
+    constructor(data?: string[] | string);
+    append(e: Node): void;
+    render(): any;
+    parent(): Node;
+}

package/dist/vendor/affine/delta-to-md/utils/node.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = void 0;
+// oxlint-disable
+// @ts-nocheck
+let id = 0;
+class Node {
+    id = ++id;
+    children;
+    open;
+    close;
+    text;
+    _format;
+    _parent;
+    constructor(data) {
+        if (Array.isArray(data)) {
+            this.open = data[0];
+            this.close = data[1];
+        }
+        else if (typeof data === 'string') {
+            this.text = data;
+        }
+        this.children = [];
+    }
+    append(e) {
+        if (!(e instanceof Node)) {
+            e = new Node(e);
+        }
+        if (e._parent) {
+            const idx = e._parent.children.indexOf(e);
+            e._parent.children.splice(idx, 1);
+        }
+        e._parent = this;
+        this.children = this.children.concat(e);
+    }
+    render() {
+        const inner = (this.text || '') + this.children.map(c => c.render()).join('');
+        if (inner.trim() === '' &&
+            this.open === this.close &&
+            this.open &&
+            this.close) {
+            return '';
+        }
+        const wrapped = this.open && this.close;
+        const emptyInner = inner.trim() === '';
+        const fragments = [
+            inner.startsWith(' ') && !emptyInner && wrapped ? ' ' : '',
+            this.open,
+            wrapped ? inner.trim() : inner,
+            this.close,
+            inner.endsWith(' ') && !emptyInner && wrapped ? ' ' : '',
+        ].filter(f => f);
+        return fragments.join('');
+    }
+    parent() {
+        return this._parent;
+    }
+}
+exports.Node = Node;

package/dist/vendor/affine/delta-to-md/utils/url.d.ts

@@ -0,0 +1 @@
+export declare const encodeLink: (link: string) => string;

package/dist/vendor/affine/delta-to-md/utils/url.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeLink = void 0;
+const encodeLink = (link) => encodeURI(link)
+    .replaceAll('(', '%28')
+    .replaceAll(')', '%29')
+    .replace(/(\?|&)response-content-disposition=attachment.*$/, '');
+exports.encodeLink = encodeLink;

package/dist/vendor/affine/parser.d.ts

@@ -0,0 +1,5 @@
+import type { BaseParsedBlock, ParsedBlock, ParsedDoc, ParserContext, YBlock, YBlocks } from './types';
+export declare const parseBlockToMd: (block: BaseParsedBlock, padding?: string) => string;
+export declare function parseBlock(context: ParserContext, yBlock: YBlock | undefined, yBlocks: YBlocks, // all blocks
+aiEditable?: boolean, blockLevel?: number): ParsedBlock | null;
+export declare const parsePageDoc: (ctx: ParserContext) => ParsedDoc;

package/dist/vendor/affine/parser.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePageDoc = exports.parseBlockToMd = void 0;
+exports.parseBlock = parseBlock;
+const yjs_1 = require("yjs");
+const delta_to_md_1 = require("./delta-to-md");
+const parseBlockToMd = (block, padding = '') => {
+    if (block.content) {
+        return (block.content
+            .split('\n')
+            .map(line => padding + line)
+            .slice(0, -1)
+            .join('\n') +
+            '\n' +
+            block.children.map(b => (0, exports.parseBlockToMd)(b, padding + '    ')).join(''));
+    }
+    else {
+        return block.children.map(b => (0, exports.parseBlockToMd)(b, padding)).join('');
+    }
+};
+exports.parseBlockToMd = parseBlockToMd;
+function parseBlock(context, yBlock, yBlocks, // all blocks
+aiEditable = false, blockLevel = 0) {
+    if (!yBlock) {
+        return null;
+    }
+    const deltaConverters = (0, delta_to_md_1.getConverters)({
+        convertInlineReferenceLink: ref => {
+            return {
+                title: ref.title || context.renderDocTitle?.(ref.pageId) || '',
+                link: context.buildDocUrl(ref.pageId),
+            };
+        },
+    });
+    const id = yBlock.get('sys:id');
+    const flavour = yBlock.get('sys:flavour');
+    const type = yBlock.get('prop:type');
+    const toMd = () => (0, delta_to_md_1.deltaToMd)(yBlock.get('prop:text').toDelta(), deltaConverters);
+    const hidden = yBlock.get('prop:hidden');
+    const displayMode = yBlock.get('prop:displayMode');
+    const childrenIds = yBlock.get('sys:children') instanceof yjs_1.Array
+        ? yBlock.get('sys:children').toJSON()
+        : [];
+    let result = {
+        id,
+        flavour,
+        content: '',
+        children: [],
+        type,
+    };
+    if (hidden || displayMode === 'edgeless') {
+        return result;
+    }
+    let placeholder = false;
+    try {
+        switch (flavour) {
+            case 'affine:paragraph': {
+                let initial = '';
+                if (type === 'h1') {
+                    initial = '# ';
+                }
+                else if (type === 'h2') {
+                    initial = '## ';
+                }
+                else if (type === 'h3') {
+                    initial = '### ';
+                }
+                else if (type === 'h4') {
+                    initial = '#### ';
+                }
+                else if (type === 'h5') {
+                    initial = '##### ';
+                }
+                else if (type === 'h6') {
+                    initial = '###### ';
+                }
+                else if (type === 'quote') {
+                    initial = '> ';
+                }
+                result.content = initial + toMd() + '\n';
+                break;
+            }
+            case 'affine:divider': {
+                result.content = '\n---\n\n';
+                break;
+            }
+            case 'affine:list': {
+                let prefix = type === 'bulleted' ? '* ' : '1. ';
+                if (type === 'todo') {
+                    const checked = yBlock.get('prop:checked');
+                    prefix = checked ? '- [x] ' : '- [ ] ';
+                }
+                result.content = prefix + toMd();
+                break;
+            }
+            case 'affine:code': {
+                const lang = yBlock.get('prop:language')?.toLowerCase() || 'txt';
+                // do not transform to delta for code block
+                const caption = yBlock.get('prop:caption');
+                result.content =
+                    '```' +
+                        lang +
+                        (caption ? ` ${caption}` : '') +
+                        '\n' +
+                        yBlock.get('prop:text').toJSON() +
+                        '\n```\n\n';
+                break;
+            }
+            case 'affine:image': {
+                const sourceId = yBlock.get('prop:sourceId');
+                const width = yBlock.get('prop:width');
+                const height = yBlock.get('prop:height');
+                // fixme: this may not work if workspace is not public
+                const blobUrl = context.buildBlobUrl(sourceId);
+                const caption = yBlock.get('prop:caption');
+                if (width || height || caption) {
+                    result.content =
+                        `<img
+                src="${blobUrl}"
+                alt="${caption}"
+                width="${width || 'auto'}"
+                height="${height || 'auto'}"
+              />
+            ` + '\n\n';
+                }
+                else {
+                    result.content = `\n![${caption || sourceId}](${blobUrl})\n\n`;
+                }
+                Object.assign(result, {
+                    sourceId,
+                    width,
+                    height,
+                    caption,
+                    blobUrl,
+                });
+                break;
+            }
+            case 'affine:attachment': {
+                const sourceId = yBlock.get('prop:sourceId');
+                const blobUrl = context.buildBlobUrl(sourceId);
+                const caption = yBlock.get('prop:caption');
+                if (type.startsWith('video')) {
+                    result.content =
+                        `<video muted autoplay loop preload="auto" playsinline>
+               <source src="${blobUrl}" type="${type}" />
+             </video>
+            ` + '\n\n';
+                }
+                else {
+                    // assume it is an image
+                    result.content = `\n![${caption || sourceId}](${blobUrl})\n\n`;
+                }
+                Object.assign(result, {
+                    sourceId,
+                    blobUrl,
+                    caption,
+                });
+                break;
+            }
+            case 'affine:embed-youtube': {
+                const videoId = yBlock.get('prop:videoId');
+                // prettier-ignore
+                result.content = `
+        <iframe
+          type="text/html"
+          width="100%"
+          height="410px"
+          src="https://www.youtube.com/embed/${videoId}"
+          frameborder="0"
+          allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+          allowfullscreen
+          credentialless>
+        </iframe>` + '\n\n';
+                break;
+            }
+            case 'affine:bookmark': {
+                const url = yBlock.get('prop:url');
+                const caption = yBlock.get('prop:caption');
+                result.content = `\n[](Bookmark,${url})\n\n`;
+                Object.assign(result, {
+                    url,
+                    caption,
+                });
+                break;
+            }
+            case 'affine:embed-linked-doc':
+            case 'affine:embed-synced-doc': {
+                const pageId = yBlock.get('prop:pageId');
+                const caption = yBlock.get('prop:caption');
+                result.content = `\n[${caption}](${context.buildDocUrl(pageId)})\n\n`;
+                Object.assign(result, {
+                    pageId,
+                    caption,
+                });
+                break;
+            }
+            case 'affine:surface':
+            case 'affine:page':
+            case 'affine:note':
+            case 'affine:frame': {
+                result.content = '';
+                break;
+            }
+            case 'affine:database': {
+                const title = yBlock.get('prop:title').toJSON();
+                const childrenTitleById = Object.fromEntries(childrenIds.map(cid => {
+                    const child = parseBlock(context, yBlocks.get(cid), yBlocks, aiEditable, blockLevel + 1);
+                    if (!child) {
+                        return [cid, ''];
+                    }
+                    return [cid, (0, exports.parseBlockToMd)(child)];
+                }));
+                const cols = yBlock.get('prop:columns').toJSON();
+                const cells = yBlock.get('prop:cells').toJSON();
+                const optionToTagHtml = (option) => {
+                    return `<span data-affine-option data-value="${option.id}" data-option-color="${option.color}">${option.value}</span>`;
+                };
+                const dbRows = childrenIds
+                    .map(cid => {
+                    const row = cells[cid];
+                    return cols.map(col => {
+                        const value = row?.[col.id]?.value;
+                        if (col.type !== 'title' && !value) {
+                            return '';
+                        }
+                        switch (col.type) {
+                            case 'title':
+                                return childrenTitleById[cid];
+                            case 'select':
+                                return optionToTagHtml(col.data['options'].find((opt) => opt.id === value));
+                            case 'multi-select':
+                                return col.data['options']
+                                    .filter((opt) => value.includes(opt.id))
+                                    .map(optionToTagHtml)
+                                    .join('');
+                            default:
+                                return value ?? '';
+                        }
+                    });
+                })
+                    .filter(row => !row.every(v => !v));
+                const header = cols.map(col => {
+                    return col.name;
+                });
+                const divider = cols.map(() => {
+                    return '---';
+                });
+                // convert to markdown table
+                result.content =
+                    [header, divider, ...dbRows]
+                        .map(row => {
+                        return ('|' +
+                            row
+                                .map(cell => String(cell || '')?.trim())
+                                .join('|')
+                                .replace(/\n+/g, '<br />') +
+                            '|');
+                    })
+                        .join('\n') + '\n\n';
+                Object.assign(result, {
+                    title,
+                    rows: dbRows.map(row => {
+                        return Object.fromEntries(row.map((v, i) => [cols[i].name, v]));
+                    }),
+                });
+                break;
+            }
+            case 'affine:table': {
+                // Extract row IDs and their order
+                const rowEntries = Object.entries(yBlock.toJSON())
+                    .filter(([key]) => key.startsWith('prop:rows.') && key.endsWith('.rowId'))
+                    .map(([key, value]) => {
+                    const rowId = value;
+                    const orderKey = key.replace('.rowId', '.order');
+                    const order = yBlock.get(orderKey);
+                    const backgroundColor = yBlock.get(key.replace('.rowId', '.backgroundColor'));
+                    return { rowId, order, backgroundColor };
+                })
+                    .sort((a, b) => a.order.localeCompare(b.order));
+                // Extract column IDs and their order
+                const columnEntries = Object.entries(yBlock.toJSON())
+                    .filter(([key]) => key.startsWith('prop:columns.') && key.endsWith('.columnId'))
+                    .map(([key, value]) => {
+                    const columnId = value;
+                    const orderKey = key.replace('.columnId', '.order');
+                    const order = yBlock.get(orderKey);
+                    return { columnId, order };
+                })
+                    .sort((a, b) => a.order.localeCompare(b.order));
+                // Build the table rows with cell data
+                const tableRows = rowEntries.map(({ rowId }) => {
+                    return columnEntries.map(({ columnId }) => {
+                        const cellKey = `prop:cells.${rowId}:${columnId}.text`;
+                        const cellText = yBlock.get(cellKey);
+                        return cellText || '';
+                    });
+                });
+                // Store column IDs for reference
+                const columnIds = columnEntries.map(({ columnId }) => columnId);
+                // Use the first row as header and the rest as data rows
+                if (tableRows.length > 0) {
+                    const headerRow = tableRows[0];
+                    const dataRows = tableRows.slice(1);
+                    const separators = headerRow.map(() => '---');
+                    // Convert to markdown table with first row as header
+                    result.content =
+                        [headerRow, separators, ...dataRows]
+                            .map(row => {
+                            return ('|' +
+                                row
+                                    .map(cell => String(cell || '')?.trim())
+                                    .join('|')
+                                    .replace(/\n+/g, '<br />') +
+                                '|');
+                        })
+                            .join('\n') + '\n\n';
+                }
+                else {
+                    // Handle empty table case
+                    result.content = '';
+                }
+                Object.assign(result, {
+                    columns: columnIds,
+                    rows: tableRows,
+                });
+                break;
+            }
+            default: {
+                // console.warn("Unknown or unsupported flavour", flavour);
+                placeholder = true;
+            }
+        }
+        result.children =
+            flavour !== 'affine:database'
+                ? childrenIds
+                    .map(cid => parseBlock(context, yBlocks.get(cid), yBlocks, aiEditable, blockLevel + 1))
+                    .filter((block) => !!block &&
+                    !(block.content === '' && block.children.length === 0))
+                : [];
+    }
+    catch (e) {
+        console.warn('Error converting block to md', e);
+    }
+    if (result.content && aiEditable && blockLevel === 2) {
+        // add a placeholder comment for the block level 2
+        if (flavour === 'affine:database' || placeholder) {
+            result.content = `<!-- block_id=${id} flavour=${flavour} placeholder -->\n`;
+            result.children = [];
+        }
+        else {
+            result.content = `<!-- block_id=${id} flavour=${flavour} -->\n${result.content}`;
+        }
+    }
+    return result;
+}
+const parsePageDoc = (ctx) => {
+    // we assume that the first block is the page block
+    const yBlocks = ctx.doc.getMap('blocks');
+    const maybePageBlock = Object.entries(yBlocks.toJSON()).findLast(([_, b]) => b['sys:flavour'] === 'affine:page');
+    // there are cases that the page is empty due to some weird issues
+    if (!maybePageBlock) {
+        return {
+            title: '',
+            md: '',
+        };
+    }
+    else {
+        const yPage = yBlocks.get(maybePageBlock[0]);
+        const title = yPage.get('prop:title');
+        const rootBlock = parseBlock(ctx, yPage, yBlocks, ctx.aiEditable);
+        if (!rootBlock) {
+            return {
+                title: '',
+                md: '',
+            };
+        }
+        rootBlock.children = rootBlock.children.filter((block) => block.flavour === 'affine:note');
+        const md = (0, exports.parseBlockToMd)(rootBlock);
+        return {
+            title: title.toJSON(),
+            parsedBlock: rootBlock,
+            md,
+        };
+    }
+};
+exports.parsePageDoc = parsePageDoc;