@dinoxx/dinox-cli 1.0.17 → 1.0.19

package/dist/utils/tiptapMarkdownSchema.js

@@ -0,0 +1,577 @@
+import Blockquote from '@tiptap/extension-blockquote';
+import Bold from '@tiptap/extension-bold';
+import BulletList from '@tiptap/extension-bullet-list';
+import Code from '@tiptap/extension-code';
+import CodeBlock from '@tiptap/extension-code-block';
+import Document from '@tiptap/extension-document';
+import HardBreak from '@tiptap/extension-hard-break';
+import Heading from '@tiptap/extension-heading';
+import Highlight from '@tiptap/extension-highlight';
+import Image from '@tiptap/extension-image';
+import Italic from '@tiptap/extension-italic';
+import Link from '@tiptap/extension-link';
+import { ListItem, OrderedList, TaskItem, TaskList } from '@tiptap/extension-list';
+import { Mathematics } from '@tiptap/extension-mathematics';
+import Paragraph from '@tiptap/extension-paragraph';
+import Strike from '@tiptap/extension-strike';
+import { Table } from '@tiptap/extension-table';
+import { TableCell } from '@tiptap/extension-table-cell';
+import { TableHeader } from '@tiptap/extension-table-header';
+import { TableRow } from '@tiptap/extension-table-row';
+import Text from '@tiptap/extension-text';
+import Underline from '@tiptap/extension-underline';
+import HorizontalRule from '@tiptap/extension-horizontal-rule';
+import { MarkdownManager } from '@tiptap/markdown';
+import { Node, createInlineMarkdownSpec, nodeInputRule } from '@tiptap/core';
+import { buildFrontmatterMarkdownBlock, buildImageWidthPercentStyle, extractAudioAttrsFromHtml, extractVideoAttrsFromHtml, findHashtagPathStart, IMAGE_WIDTH_PERCENT_ATTR, inferMimeTypeFromHref, normalizeAudioMarkdownAttrs, normalizeDinoxImageAttrs, normalizeFileBlockAttrs, normalizeFrontmatterRaw, normalizeStoredImageWidthPercent, normalizeVideoMarkdownAttrs, parseHashtagPath, parseMarkdownAttributes, serializeMarkdownAttributes, } from './tiptapMarkdownSchemaUtils.js';
+const EditorDocument = Document.extend({
+    content: 'frontmatter? block+',
+});
+const FRONTMATTER_BLOCK_RE = /^(?:\uFEFF)?---[ \t]*\n([\s\S]*?)\n---[ \t]*(?:\n|$)/;
+const FrontmatterNode = Node.create({
+    name: 'frontmatter',
+    group: 'frontmatter',
+    atom: true,
+    defining: true,
+    isolating: true,
+    addAttributes() {
+        return {
+            raw: {
+                default: '',
+            },
+        };
+    },
+    renderText({ node }) {
+        return buildFrontmatterMarkdownBlock(node.attrs?.raw);
+    },
+    parseMarkdown(token, helpers) {
+        return helpers.createNode('frontmatter', {
+            raw: normalizeFrontmatterRaw(token.content),
+        });
+    },
+    renderMarkdown(node) {
+        return buildFrontmatterMarkdownBlock(node.attrs?.raw);
+    },
+    markdownTokenizer: {
+        name: 'frontmatter',
+        level: 'block',
+        start(src) {
+            return src.match(/^(?:\uFEFF)?---[ \t]*\n/)?.index ?? -1;
+        },
+        tokenize(src, tokens) {
+            if (tokens.length > 0) {
+                return undefined;
+            }
+            const match = src.match(FRONTMATTER_BLOCK_RE);
+            if (!match) {
+                return undefined;
+            }
+            return {
+                type: 'frontmatter',
+                raw: match[0],
+                content: normalizeFrontmatterRaw(match[1] ?? ''),
+            };
+        },
+    },
+});
+const DinoxImage = Image.extend({
+    addAttributes() {
+        return {
+            ...(this.parent?.() ?? {}),
+            resourceId: {
+                default: null,
+            },
+            storageKey: {
+                default: null,
+            },
+            widthPercent: {
+                default: null,
+                renderHTML: (attributes) => {
+                    const widthPercent = normalizeStoredImageWidthPercent(attributes.widthPercent);
+                    const style = buildImageWidthPercentStyle(widthPercent);
+                    if (widthPercent == null || !style) {
+                        return {};
+                    }
+                    return {
+                        [IMAGE_WIDTH_PERCENT_ATTR]: String(widthPercent),
+                        style,
+                    };
+                },
+            },
+        };
+    },
+    parseMarkdown(token, helpers) {
+        const attrs = normalizeDinoxImageAttrs({
+            alt: token.text,
+            src: token.href,
+            title: token.title,
+        });
+        if (!attrs.src) {
+            return [];
+        }
+        return helpers.createNode('image', attrs);
+    },
+    addInputRules() {
+        return [
+            nodeInputRule({
+                find: /(?:^|\s)(!\[(.*?)\]\((\S+)(?:\s+"(.*?)")?\))$/,
+                type: this.type,
+                getAttributes: (match) => {
+                    const [, , alt, src, title] = match;
+                    return normalizeDinoxImageAttrs({ alt, src, title });
+                },
+            }),
+        ];
+    },
+});
+const AudioNode = Node.create({
+    name: 'audio',
+    group: 'block',
+    atom: true,
+    addAttributes() {
+        return {
+            preload: { default: null },
+            resourceId: { default: null },
+            src: { default: null },
+            storageKey: { default: null },
+            title: { default: null },
+        };
+    },
+    renderText({ node }) {
+        return String(node.attrs?.title || node.attrs?.src || '').trim();
+    },
+    parseMarkdown(token, helpers) {
+        const attrs = normalizeAudioMarkdownAttrs((token.attributes || {}));
+        return attrs.src ? helpers.createNode('audio', attrs, []) : [];
+    },
+    markdownTokenizer: {
+        name: 'audio',
+        level: 'block',
+        start(src) {
+            return src.search(/<audio\b/i);
+        },
+        tokenize(src) {
+            const htmlMatch = src.match(/^<audio\b[\s\S]*?(?:<\/audio>|\/>)(?:\n|$)?/i);
+            if (!htmlMatch) {
+                return undefined;
+            }
+            const attrs = extractAudioAttrsFromHtml(htmlMatch[0]);
+            return attrs?.src
+                ? {
+                    type: 'audio',
+                    raw: htmlMatch[0],
+                    attributes: attrs,
+                }
+                : undefined;
+        },
+    },
+});
+const VideoNode = Node.create({
+    name: 'video',
+    group: 'block',
+    atom: true,
+    addAttributes() {
+        return {
+            autoplay: { default: false },
+            loop: { default: false },
+            muted: { default: false },
+            playsInline: { default: false },
+            poster: { default: null },
+            resourceId: { default: null },
+            src: { default: null },
+            storageKey: { default: null },
+            title: { default: null },
+        };
+    },
+    renderText({ node }) {
+        return String(node.attrs?.title || node.attrs?.src || '').trim();
+    },
+    parseMarkdown(token, helpers) {
+        const attrs = normalizeVideoMarkdownAttrs((token.attributes || {}));
+        return attrs.src ? helpers.createNode('video', attrs, []) : [];
+    },
+    markdownTokenizer: {
+        name: 'video',
+        level: 'block',
+        start(src) {
+            return src.search(/<video\b/i);
+        },
+        tokenize(src) {
+            const htmlMatch = src.match(/^<video\b[\s\S]*?(?:<\/video>|\/>)(?:\n|$)?/i);
+            if (!htmlMatch) {
+                return undefined;
+            }
+            const attrs = extractVideoAttrsFromHtml(htmlMatch[0]);
+            return attrs?.src
+                ? {
+                    type: 'video',
+                    raw: htmlMatch[0],
+                    attributes: attrs,
+                }
+                : undefined;
+        },
+    },
+});
+const FileNode = Node.create({
+    name: 'file',
+    group: 'block',
+    atom: true,
+    defining: true,
+    addAttributes() {
+        return {
+            id: { default: '' },
+            name: { default: '未命名文件' },
+            resourceId: { default: '' },
+            size: { default: 0 },
+            src: { default: '' },
+            type: { default: 'application/octet-stream' },
+        };
+    },
+    renderText({ node }) {
+        return normalizeFileBlockAttrs((node.attrs || {})).name;
+    },
+});
+const AudioSegmentNode = Node.create({
+    name: 'audiosegment',
+    group: 'block',
+    atom: true,
+    defining: true,
+    addAttributes() {
+        return {
+            id: { default: null },
+            speaker: { default: '' },
+            t0: { default: 0 },
+            t1: { default: 0 },
+            text: { default: '' },
+        };
+    },
+    renderText({ node }) {
+        return String(node.attrs?.text || '');
+    },
+    parseMarkdown(token, helpers) {
+        const t0 = Number(token.attributes?.t0);
+        const t1 = Number(token.attributes?.t1);
+        return helpers.createNode('audiosegment', {
+            ...token.attributes,
+            t0: Number.isFinite(t0) ? t0 : 0,
+            t1: Number.isFinite(t1) ? t1 : 0,
+            text: typeof token.content === 'string' ? token.content : '',
+        }, []);
+    },
+    renderMarkdown(node) {
+        const attrs = node.attrs || {};
+        const attrString = serializeMarkdownAttributes({
+            id: attrs.id,
+            speaker: attrs.speaker,
+            t0: attrs.t0,
+            t1: attrs.t1,
+        }, ['id', 't0', 't1', 'speaker']);
+        const header = attrString ? `:::audiosegment {${attrString}}` : ':::audiosegment';
+        return `${header}\n${String(attrs.text || '')}\n:::`;
+    },
+    markdownTokenizer: {
+        name: 'audiosegment',
+        level: 'block',
+        start(src) {
+            const match = src.match(/^:::audiosegment(?:\s|$)/m);
+            return match?.index ?? -1;
+        },
+        tokenize(src) {
+            const match = src.match(/^:::audiosegment(?:\s+\{([^}]*)\})?\s*\n([\s\S]*?)\n:::(?:\n|$)?/);
+            if (!match) {
+                return undefined;
+            }
+            return {
+                type: 'audiosegment',
+                raw: match[0],
+                content: match[2] || '',
+                attributes: parseMarkdownAttributes(match[1] || ''),
+            };
+        },
+    },
+});
+const HashtagNode = Node.create({
+    name: 'hashtag',
+    group: 'inline',
+    inline: true,
+    atom: true,
+    addAttributes() {
+        return {
+            id: { default: null },
+            label: { default: null },
+        };
+    },
+    renderText({ node }) {
+        return `#${String(node.attrs?.label || node.attrs?.id || '').trim()}`;
+    },
+    parseMarkdown(token, helpers) {
+        const label = typeof token.attributes?.label === 'string' ? token.attributes.label : '';
+        const id = typeof token.attributes?.id === 'string' && token.attributes.id ? token.attributes.id : label;
+        return label || id ? helpers.createNode('hashtag', { id, label: label || id }) : [];
+    },
+    markdownTokenizer: {
+        name: 'hashtag',
+        level: 'inline',
+        start(src) {
+            return findHashtagPathStart(src);
+        },
+        tokenize(src) {
+            const parsed = parseHashtagPath(src, 0);
+            return parsed
+                ? {
+                    type: 'hashtag',
+                    raw: parsed.raw,
+                    attributes: {
+                        id: parsed.label,
+                        label: parsed.label,
+                    },
+                }
+                : undefined;
+        },
+    },
+});
+const BidLinkNode = Node.create({
+    name: 'bidlink',
+    group: 'inline',
+    inline: true,
+    atom: true,
+    addAttributes() {
+        return {
+            id: { default: null },
+            label: { default: null },
+        };
+    },
+    renderText({ node }) {
+        return String(node.attrs?.label || node.attrs?.id || '').trim();
+    },
+    parseMarkdown(token, helpers) {
+        const label = typeof token.attributes?.label === 'string' ? token.attributes.label : '';
+        const id = typeof token.attributes?.id === 'string' && token.attributes.id ? token.attributes.id : label;
+        return label || id ? helpers.createNode('bidlink', { id, label: label || id }) : [];
+    },
+    markdownTokenizer: {
+        name: 'bidlink',
+        level: 'inline',
+        start(src) {
+            const index = src.indexOf('[[');
+            return index >= 0 ? index : -1;
+        },
+        tokenize(src) {
+            const match = src.match(/^\[\[((?:\\.|[^\]\n])+?)\]\]/);
+            if (!match) {
+                return undefined;
+            }
+            const rawValue = match[1].trim();
+            if (!rawValue) {
+                return undefined;
+            }
+            let separatorIndex = -1;
+            for (let index = rawValue.length - 1; index >= 0; index -= 1) {
+                if (rawValue[index] === '|' && rawValue[index - 1] !== '\\') {
+                    separatorIndex = index;
+                    break;
+                }
+            }
+            const unescape = (value) => value.replace(/\\([\\|\]])/g, '$1');
+            const label = unescape(separatorIndex >= 0 ? rawValue.slice(0, separatorIndex).trim() : rawValue.trim());
+            const id = unescape(separatorIndex >= 0 ? rawValue.slice(separatorIndex + 1).trim() || label : label);
+            return {
+                type: 'bidlink',
+                raw: match[0],
+                attributes: {
+                    id,
+                    label,
+                },
+            };
+        },
+    },
+});
+const MentionNode = Node.create({
+    name: 'mention',
+    group: 'inline',
+    inline: true,
+    atom: true,
+    addAttributes() {
+        return {
+            id: { default: null },
+            label: { default: null },
+            marker: { default: '#' },
+        };
+    },
+    renderText({ node }) {
+        return String(node.attrs?.label || node.attrs?.id || '').trim();
+    },
+    ...createInlineMarkdownSpec({
+        nodeName: 'mention',
+        selfClosing: true,
+        allowedAttributes: ['id', 'label', 'marker'],
+    }),
+});
+const LocationNode = Node.create({
+    name: 'location',
+    group: 'inline',
+    inline: true,
+    atom: true,
+    addAttributes() {
+        return {
+            address: { default: '' },
+            latitude: { default: null },
+            longitude: { default: null },
+            name: { default: '' },
+        };
+    },
+    renderText({ node }) {
+        return String(node.attrs?.name || '').trim();
+    },
+    ...createInlineMarkdownSpec({
+        nodeName: 'location',
+        selfClosing: true,
+        allowedAttributes: ['name', 'address', 'latitude', 'longitude'],
+        parseAttributes: (attrString) => {
+            const attrs = parseMarkdownAttributes(attrString);
+            return {
+                address: attrs.address || '',
+                latitude: attrs.latitude ? Number(attrs.latitude) : null,
+                longitude: attrs.longitude ? Number(attrs.longitude) : null,
+                name: attrs.name || '',
+            };
+        },
+        serializeAttributes: (attrs) => serializeMarkdownAttributes({
+            address: attrs.address,
+            latitude: attrs.latitude,
+            longitude: attrs.longitude,
+            name: attrs.name,
+        }, ['name', 'address', 'latitude', 'longitude']),
+    }),
+});
+const TimeNode = Node.create({
+    name: 'time',
+    group: 'inline',
+    inline: true,
+    atom: true,
+    addAttributes() {
+        return {
+            displayFormat: { default: 'datetime' },
+            iso: { default: '' },
+        };
+    },
+    renderText({ node }) {
+        return String(node.attrs?.iso || '').trim();
+    },
+    ...createInlineMarkdownSpec({
+        nodeName: 'time',
+        selfClosing: true,
+        allowedAttributes: ['iso', 'displayFormat'],
+        parseAttributes: (attrString) => {
+            const attrs = parseMarkdownAttributes(attrString);
+            return {
+                displayFormat: attrs.displayFormat || 'datetime',
+                iso: attrs.iso || '',
+            };
+        },
+        serializeAttributes: (attrs) => serializeMarkdownAttributes({
+            displayFormat: attrs.displayFormat,
+            iso: attrs.iso,
+        }, ['iso', 'displayFormat']),
+    }),
+});
+export function createDinoxMarkdownExtensions() {
+    return [
+        EditorDocument,
+        FrontmatterNode,
+        Paragraph,
+        Text,
+        Bold,
+        Italic,
+        Strike,
+        Underline,
+        Code,
+        CodeBlock,
+        Link.configure({
+            openOnClick: false,
+        }),
+        HardBreak,
+        Heading,
+        Blockquote,
+        BulletList,
+        OrderedList,
+        ListItem,
+        TaskList,
+        TaskItem.configure({
+            nested: true,
+        }),
+        Highlight.configure({}),
+        HorizontalRule,
+        DinoxImage.configure({
+            allowBase64: true,
+            inline: false,
+        }),
+        Mathematics,
+        Table.configure({
+            lastColumnResizable: false,
+            resizable: true,
+        }),
+        TableHeader,
+        TableCell,
+        TableRow,
+        VideoNode,
+        HashtagNode,
+        BidLinkNode,
+        MentionNode,
+        LocationNode,
+        TimeNode,
+        AudioSegmentNode,
+        AudioNode,
+        FileNode,
+    ];
+}
+let markdownManager = null;
+export function getDinoxMarkdownManager() {
+    if (!markdownManager) {
+        markdownManager = new MarkdownManager({
+            extensions: createDinoxMarkdownExtensions(),
+        });
+    }
+    return markdownManager;
+}
+export function createVideoNodeFromLink(input) {
+    return {
+        type: 'video',
+        attrs: normalizeVideoMarkdownAttrs({
+            resourceId: input.resourceId,
+            src: input.href,
+            title: input.label,
+        }),
+    };
+}
+export function createAudioNodeFromLink(input) {
+    return {
+        type: 'audio',
+        attrs: normalizeAudioMarkdownAttrs({
+            resourceId: input.resourceId,
+            src: input.href,
+            title: input.label,
+        }),
+    };
+}
+export function createFileNodeFromLink(input) {
+    return {
+        type: 'file',
+        attrs: normalizeFileBlockAttrs({
+            name: input.label,
+            resourceId: input.resourceId ?? undefined,
+            src: input.href,
+            type: inferMimeTypeFromHref(input.href),
+        }),
+    };
+}
+export function createImageNodeWithMetadata(attrs, metadata) {
+    return {
+        type: 'image',
+        attrs: normalizeDinoxImageAttrs({
+            ...attrs,
+            resourceId: metadata.resourceId ?? attrs.resourceId,
+            widthPercent: metadata.widthPercent ?? attrs.widthPercent,
+        }),
+    };
+}

package/dist/utils/tiptapMarkdownSchemaUtils.d.ts

@@ -0,0 +1,74 @@
+declare const DEFAULT_FILE_TYPE = "application/octet-stream";
+declare const IMAGE_WIDTH_PERCENT_ATTR = "data-dinox-width-percent";
+declare const MEDIA_RESOURCE_ID_ATTR = "data-resource-id";
+declare const MEDIA_STORAGE_KEY_ATTR = "data-storage-key";
+export type DinoxMarkdownMediaKind = 'image' | 'video' | 'audio' | 'file';
+export type DinoxMarkdownComment = {
+    kind: DinoxMarkdownMediaKind | null;
+    resourceId: string | null;
+    widthPercent: number | null;
+};
+export type DinoxImageAttrs = {
+    alt: string | null;
+    height: number | null;
+    resourceId: string | null;
+    src: string | null;
+    storageKey: string | null;
+    title: string | null;
+    width: number | null;
+    widthPercent: number | null;
+};
+export type AudioMarkdownAttrs = {
+    preload?: string;
+    resourceId?: string;
+    src?: string;
+    storageKey?: string;
+    title?: string;
+};
+export type VideoMarkdownAttrs = {
+    autoplay?: boolean;
+    loop?: boolean;
+    muted?: boolean;
+    playsInline?: boolean;
+    poster?: string;
+    resourceId?: string;
+    src?: string;
+    storageKey?: string;
+    title?: string;
+};
+export type FileBlockAttrs = {
+    id: string;
+    name: string;
+    resourceId?: string;
+    size: number;
+    src: string;
+    type: string;
+};
+export type ParsedHashtagPath = {
+    end: number;
+    label: string;
+    raw: string;
+};
+export declare function parseMarkdownAttributes(attrString: string): Record<string, string>;
+export declare function serializeMarkdownAttributes(attrs: Record<string, unknown>, allowedKeys?: string[]): string;
+export declare function normalizeMarkdownLineEndings(value: string): string;
+export declare function normalizeFrontmatterRaw(raw: unknown): string;
+export declare function buildFrontmatterMarkdownBlock(raw: unknown): string;
+export declare function extractMarkdownFrontmatter(markdown: string): {
+    body: string;
+    frontmatter: string | null;
+};
+export declare function normalizeStoredImageWidthPercent(value: unknown): number | null;
+export declare function parseImageWidthPercentFromStyle(styleValue: unknown): number | null;
+export declare function buildImageWidthPercentStyle(widthPercent: unknown): string | null;
+export declare function normalizeDinoxImageAttrs(input: Record<string, unknown>): DinoxImageAttrs;
+export declare function normalizeAudioMarkdownAttrs(input: Record<string, unknown>): AudioMarkdownAttrs;
+export declare function normalizeVideoMarkdownAttrs(input: Record<string, unknown>): VideoMarkdownAttrs;
+export declare function normalizeFileBlockAttrs(input: Partial<FileBlockAttrs>): FileBlockAttrs;
+export declare function inferMimeTypeFromHref(href: string): string | undefined;
+export declare function parseDinoxMarkdownComment(rawComment: unknown): DinoxMarkdownComment | null;
+export declare function extractAudioAttrsFromHtml(html: string): AudioMarkdownAttrs | null;
+export declare function extractVideoAttrsFromHtml(html: string): VideoMarkdownAttrs | null;
+export declare function parseHashtagPath(source: string, hashIndex: number): ParsedHashtagPath | null;
+export declare function findHashtagPathStart(source: string): number;
+export { DEFAULT_FILE_TYPE, IMAGE_WIDTH_PERCENT_ATTR, MEDIA_RESOURCE_ID_ATTR, MEDIA_STORAGE_KEY_ATTR, };