@dinoxx/dinox-cli 1.0.17 → 1.0.19

package/dist/utils/terminalSanitization.js

@@ -0,0 +1,33 @@
+const ANSI_ESCAPE_RE = /\x1b\[[0-9;?>=!]*[a-zA-Z]|\x1b\][^\x07]*\x07/g;
+export function isDangerousUnicode(rune) {
+    return ((rune >= 0x200b && rune <= 0x200d) ||
+        rune === 0xfeff ||
+        (rune >= 0x202a && rune <= 0x202e) ||
+        (rune >= 0x2028 && rune <= 0x2029) ||
+        (rune >= 0x2066 && rune <= 0x2069));
+}
+export function sanitizeForTerminal(text) {
+    let sanitized = text;
+    if (sanitized.includes('\x1b')) {
+        sanitized = sanitized.replace(ANSI_ESCAPE_RE, '');
+    }
+    let result = '';
+    for (const char of sanitized) {
+        const code = char.codePointAt(0);
+        if (code === undefined) {
+            continue;
+        }
+        if (char === '\n' || char === '\t') {
+            result += char;
+            continue;
+        }
+        if (code < 0x20 || code === 0x7f) {
+            continue;
+        }
+        if (isDangerousUnicode(code)) {
+            continue;
+        }
+        result += char;
+    }
+    return result;
+}

package/dist/utils/tiptapMarkdown.d.ts

@@ -1,6 +1,9 @@
-import { type JSONContent } from '@tiptap/core';
+import type { JSONContent } from '@tiptap/core';
+import { createAudioNodeFromLink, createFileNodeFromLink, createImageNodeWithMetadata, createVideoNodeFromLink } from './tiptapMarkdownSchema.js';
+import { inferMimeTypeFromHref, normalizeFileBlockAttrs } from './tiptapMarkdownSchemaUtils.js';
 export type MarkdownConversion = {
     contentJson: JSONContent;
     contentText: string;
 };
 export declare function convertMarkdownToNoteContent(markdown: string): MarkdownConversion;
+export { createAudioNodeFromLink, createFileNodeFromLink, createImageNodeWithMetadata, createVideoNodeFromLink, inferMimeTypeFromHref, normalizeFileBlockAttrs, };

package/dist/utils/tiptapMarkdown.js

@@ -1,109 +1,222 @@
-import { Editor } from '@tiptap/core';
-import { Image } from '@tiptap/extension-image';
-import { ListItem } from '@tiptap/extension-list';
-import { Markdown } from '@tiptap/markdown';
-import { StarterKit } from '@tiptap/starter-kit';
-import { TableKit } from '@tiptap/extension-table';
-import { UniqueID, generateUniqueIds } from '@tiptap/extension-unique-id';
 import { DinoxError } from './errors.js';
 import { generateId } from './id.js';
-const EMPTY_PARAGRAPH = { type: 'paragraph', content: [] };
+import { createAudioNodeFromLink, createFileNodeFromLink, createImageNodeWithMetadata, createVideoNodeFromLink, getDinoxMarkdownManager, } from './tiptapMarkdownSchema.js';
+import { inferMimeTypeFromHref, normalizeDinoxImageAttrs, normalizeFileBlockAttrs, normalizeFrontmatterRaw, parseDinoxMarkdownComment, } from './tiptapMarkdownSchemaUtils.js';
 const CONTENT_PREVIEW_MAX_LENGTH = 400;
-const markdownExtension = Markdown.configure({
-    markedOptions: {
-        gfm: true,
-    },
-});
-const uniqueIdExtension = UniqueID.configure({
-    attributeName: 'id',
-    types: [
-        'heading',
-        'paragraph',
-        'blockquote',
-        'codeBlock',
-        'listItem',
-        'table',
-        'tableRow',
-        'tableCell',
-        'tableHeader',
-    ],
-    generateID: () => generateId(),
-    updateDocument: false,
-});
-function ensureLeadingParagraph(content) {
-    if (content.length === 0) {
-        return [EMPTY_PARAGRAPH];
-    }
-    if (content[0]?.type === 'paragraph') {
-        return content;
-    }
-    return [EMPTY_PARAGRAPH, ...content];
-}
-// Tiptap markdown parser may produce listItem that starts with blockquote/list.
-// ProseMirror schema requires paragraph as first child (paragraph block*).
-const SafeListItem = ListItem.extend({
-    parseMarkdown: (token, helpers) => {
-        if (token.type !== 'list_item') {
-            return [];
-        }
-        let content = [];
-        if (token.tokens && token.tokens.length > 0) {
-            const hasParagraphTokens = token.tokens.some((inner) => inner.type === 'paragraph');
-            if (hasParagraphTokens) {
-                content = helpers.parseChildren(token.tokens);
-            }
-            else {
-                const firstToken = token.tokens[0];
-                if (firstToken?.type === 'text' && firstToken.tokens && firstToken.tokens.length > 0) {
-                    content = [
-                        {
-                            type: 'paragraph',
-                            content: helpers.parseInline(firstToken.tokens),
-                        },
-                    ];
-                    if (token.tokens.length > 1) {
-                        content.push(...helpers.parseChildren(token.tokens.slice(1)));
-                    }
-                }
-                else {
-                    content = helpers.parseChildren(token.tokens);
-                }
-            }
-        }
-        return {
-            type: 'listItem',
-            content: ensureLeadingParagraph(content),
-        };
-    },
-});
-const tiptapExtensions = [
-    StarterKit.configure({ listItem: false }),
-    SafeListItem,
-    Image,
-    TableKit,
-    markdownExtension,
-    uniqueIdExtension,
-];
-function sanitizeNode(node) {
-    if (!node || typeof node !== 'object') {
+const MEDIA_COMMENT_PATTERN = /<!--\s*({[\s\S]*?})\s*-->/g;
+const MEDIA_COMMENT_PLACEHOLDER_PREFIX = 'DINOX_MEDIA_META_';
+const TASK_MARKER_RE = /^\s*\[( |x|X)\]\s+/;
+function createParagraphNode(text = '') {
+    const paragraph = {
+        type: 'paragraph',
+        attrs: { id: generateId() },
+    };
+    if (text) {
+        paragraph.content = [{ type: 'text', text }];
+    }
+    return paragraph;
+}
+function createEmptyDocument() {
+    return {
+        type: 'doc',
+        content: [],
+    };
+}
+function createFallbackDocument(input) {
+    const text = typeof input === 'string' ? input : String(input || '');
+    if (!text.trim()) {
+        return createEmptyDocument();
+    }
+    return {
+        type: 'doc',
+        content: [createParagraphNode(text)],
+    };
+}
+function normalizeTaskItemContent(content) {
+    if (!Array.isArray(content) || content.length === 0) {
+        return [createParagraphNode('')];
+    }
+    const hasParagraph = content.some((child) => child?.type === 'paragraph');
+    return hasParagraph ? content : [createParagraphNode(''), ...content];
+}
+function tryConvertListItemToTaskItem(node) {
+    if (node.type !== 'listItem' || !Array.isArray(node.content) || node.content.length === 0) {
+        return null;
+    }
+    const firstParagraph = node.content.find((child) => child?.type === 'paragraph');
+    if (!firstParagraph ||
+        !Array.isArray(firstParagraph.content) ||
+        firstParagraph.content.length === 0) {
+        return null;
+    }
+    const firstInline = firstParagraph.content[0];
+    if (firstInline?.type !== 'text' || typeof firstInline.text !== 'string') {
+        return null;
+    }
+    const match = firstInline.text.match(TASK_MARKER_RE);
+    if (!match) {
+        return null;
+    }
+    firstInline.text = firstInline.text.slice(match[0].length);
+    return {
+        ...node,
+        type: 'taskItem',
+        attrs: { checked: match[1].toLowerCase() === 'x', id: generateId() },
+        content: normalizeTaskItemContent(node.content),
+    };
+}
+function normalizeTaskLists(node) {
+    if (!Array.isArray(node.content) || node.content.length === 0) {
+        return node;
+    }
+    node.content = node.content.map((child) => normalizeTaskLists(child));
+    if (node.type !== 'bulletList' && node.type !== 'orderedList') {
+        return node;
+    }
+    if (node.content.length === 0 || node.content.some((child) => child?.type !== 'listItem')) {
         return node;
     }
-    const next = { ...node };
-    if (Array.isArray(node.content)) {
-        next.content = node.content
-            .filter((child) => !!child && typeof child === 'object')
-            .map((child) => sanitizeNode(child));
+    const taskItems = node.content.map((child) => tryConvertListItemToTaskItem(child));
+    if (taskItems.some((child) => child == null)) {
+        return node;
+    }
+    return {
+        ...node,
+        type: 'taskList',
+        attrs: undefined,
+        content: taskItems,
+    };
+}
+function validateAndCleanDocument(doc) {
+    if (!doc || doc.type !== 'doc') {
+        return createEmptyDocument();
+    }
+    if (!Array.isArray(doc.content)) {
+        doc.content = [];
     }
-    if (next.type === 'listItem') {
-        const content = Array.isArray(next.content) ? next.content : [];
-        if (content.length === 0) {
-            next.content = [EMPTY_PARAGRAPH];
+    doc.content = doc.content.filter((node) => node && typeof node === 'object' && typeof node.type === 'string');
+    const normalizedContent = [];
+    let frontmatterNode = null;
+    for (const node of doc.content) {
+        if (node.type === 'frontmatter') {
+            const raw = normalizeFrontmatterRaw(node.attrs?.raw);
+            if (!raw || frontmatterNode) {
+                continue;
+            }
+            frontmatterNode = {
+                ...node,
+                attrs: {
+                    ...(node.attrs || {}),
+                    raw,
+                },
+            };
+            continue;
         }
-        else if (content[0]?.type !== 'paragraph') {
-            next.content = [EMPTY_PARAGRAPH, ...content];
+        normalizedContent.push(node);
+    }
+    doc.content = frontmatterNode ? [frontmatterNode, ...normalizedContent] : normalizedContent;
+    if (doc.content.length === 0 ||
+        (doc.content.length === 1 && doc.content[0]?.type === 'frontmatter')) {
+        doc.content.push(createParagraphNode(''));
+    }
+    return normalizeTaskLists(doc);
+}
+function preprocessMarkdownMediaComments(markdown) {
+    const metadataByPlaceholder = new Map();
+    let counter = 0;
+    const nextMarkdown = markdown.replace(MEDIA_COMMENT_PATTERN, (rawComment) => {
+        const parsed = parseDinoxMarkdownComment(rawComment);
+        if (!parsed) {
+            return rawComment;
         }
+        const placeholder = `${MEDIA_COMMENT_PLACEHOLDER_PREFIX}${counter++}__`;
+        metadataByPlaceholder.set(placeholder, parsed);
+        return placeholder;
+    });
+    return {
+        markdown: nextMarkdown,
+        metadataByPlaceholder,
+    };
+}
+function extractStandaloneMarkdownLink(content) {
+    if (!Array.isArray(content) || content.length !== 1) {
+        return null;
+    }
+    const textNode = content[0];
+    if (textNode?.type !== 'text' || typeof textNode.text !== 'string') {
+        return null;
+    }
+    const marks = Array.isArray(textNode.marks) ? textNode.marks : [];
+    if (marks.length === 0 || marks.some((mark) => mark?.type !== 'link')) {
+        return null;
+    }
+    const linkMark = marks.find((mark) => mark?.type === 'link');
+    const href = typeof linkMark?.attrs?.href === 'string' ? linkMark.attrs.href.trim() : '';
+    const label = textNode.text.trim();
+    return href && label ? { href, label } : null;
+}
+function extractMarkdownMediaCommentMetadata(node, metadataByPlaceholder) {
+    if (node?.type !== 'paragraph' || !Array.isArray(node.content) || node.content.length < 2) {
+        return null;
+    }
+    const content = [...node.content];
+    const commentNode = content[content.length - 1];
+    if (commentNode?.type !== 'text' || typeof commentNode.text !== 'string') {
+        return null;
     }
-    return next;
+    const comment = metadataByPlaceholder.get(commentNode.text.trim());
+    if (!comment) {
+        return null;
+    }
+    const meaningfulContent = content
+        .slice(0, -1)
+        .filter((child) => !(child.type === 'text' && typeof child.text === 'string' && child.text.trim() === ''));
+    return meaningfulContent.length ? { comment, content: meaningfulContent } : null;
+}
+function convertStandaloneMarkdownLinkParagraph(node, metadataByPlaceholder) {
+    const metadata = extractMarkdownMediaCommentMetadata(node, metadataByPlaceholder);
+    if (!metadata) {
+        return node;
+    }
+    if (metadata.content.length === 1 && metadata.content[0]?.type === 'image') {
+        return createImageNodeWithMetadata(normalizeDinoxImageAttrs((metadata.content[0].attrs || {})), metadata.comment);
+    }
+    const link = extractStandaloneMarkdownLink(metadata.content);
+    if (!link) {
+        return node;
+    }
+    switch (metadata.comment.kind) {
+        case 'video':
+            return createVideoNodeFromLink({
+                href: link.href,
+                label: link.label,
+                resourceId: metadata.comment.resourceId,
+            });
+        case 'audio':
+            return createAudioNodeFromLink({
+                href: link.href,
+                label: link.label,
+                resourceId: metadata.comment.resourceId,
+            });
+        case 'file':
+            return createFileNodeFromLink({
+                href: link.href,
+                label: link.label,
+                resourceId: metadata.comment.resourceId,
+            });
+        default:
+            return node;
+    }
+}
+function normalizeStandaloneMarkdownLinksToMediaBlocks(doc, metadataByPlaceholder) {
+    if (!doc || typeof doc !== 'object') {
+        return doc;
+    }
+    if (Array.isArray(doc.content)) {
+        doc.content = doc.content.map((child) => normalizeStandaloneMarkdownLinksToMediaBlocks(child, metadataByPlaceholder));
+        doc.content = doc.content.map((child) => convertStandaloneMarkdownLinkParagraph(child, metadataByPlaceholder));
+    }
+    return doc;
 }
 function normalizeContentText(text) {
     const normalized = (text ?? '').replace(/\r\n/g, '\n');
@@ -121,29 +234,88 @@ function normalizeContentText(text) {
         .replace(/\bwww\.\S+/gi, '')
         .replace(/\s{2,}/g, ' ')
         .trim();
-    if (cleaned.length <= CONTENT_PREVIEW_MAX_LENGTH) {
-        return cleaned;
+    return cleaned.length <= CONTENT_PREVIEW_MAX_LENGTH
+        ? cleaned
+        : cleaned.slice(0, CONTENT_PREVIEW_MAX_LENGTH);
+}
+function extractPreviewTextFromNode(node) {
+    if (!node || typeof node !== 'object') {
+        return '';
+    }
+    if (node.type === 'text') {
+        return typeof node.text === 'string' ? node.text : '';
     }
-    return cleaned.slice(0, CONTENT_PREVIEW_MAX_LENGTH);
+    switch (node.type) {
+        case 'audio':
+        case 'video':
+            return String(node.attrs?.title || node.attrs?.src || '').trim();
+        case 'audiosegment':
+            return String(node.attrs?.text || '').trim();
+        case 'bidlink':
+        case 'mention':
+            return String(node.attrs?.label || node.attrs?.id || '').trim();
+        case 'file':
+            return String(node.attrs?.name || '').trim();
+        case 'frontmatter':
+            return '';
+        case 'hardBreak':
+            return '\n';
+        case 'hashtag':
+            return `#${String(node.attrs?.label || node.attrs?.id || '').trim()}`;
+        case 'image':
+            return String(node.attrs?.alt || '').trim();
+        case 'location':
+            return String(node.attrs?.name || '').trim();
+        case 'time':
+            return String(node.attrs?.iso || '').trim();
+        default:
+            break;
+    }
+    if (!Array.isArray(node.content) || node.content.length === 0) {
+        return '';
+    }
+    const pieces = node.content
+        .map((child) => extractPreviewTextFromNode(child))
+        .filter((value) => value.length > 0);
+    const joined = pieces.join('');
+    if (node.type === 'blockquote' ||
+        node.type === 'bulletList' ||
+        node.type === 'codeBlock' ||
+        node.type === 'heading' ||
+        node.type === 'listItem' ||
+        node.type === 'orderedList' ||
+        node.type === 'paragraph' ||
+        node.type === 'table' ||
+        node.type === 'tableCell' ||
+        node.type === 'tableHeader' ||
+        node.type === 'tableRow' ||
+        node.type === 'taskItem' ||
+        node.type === 'taskList') {
+        return `${joined}\n`;
+    }
+    return joined;
+}
+function getPreviewTextFromDocument(contentJson) {
+    return extractPreviewTextFromNode(contentJson);
 }
 export function convertMarkdownToNoteContent(markdown) {
-    let editor = null;
     try {
-        editor = new Editor({
-            editable: false,
-            extensions: tiptapExtensions,
-            content: markdown,
-            contentType: 'markdown',
-        });
-        const sanitized = sanitizeNode(editor.getJSON());
-        const contentJson = generateUniqueIds(sanitized, tiptapExtensions);
-        const contentText = normalizeContentText(editor.getText());
+        const source = typeof markdown === 'string' ? markdown : String(markdown ?? '');
+        if (!source.trim()) {
+            return {
+                contentJson: createEmptyDocument(),
+                contentText: '',
+            };
+        }
+        const preprocessed = preprocessMarkdownMediaComments(source);
+        const parsed = getDinoxMarkdownManager().parse(preprocessed.markdown);
+        const normalized = normalizeStandaloneMarkdownLinksToMediaBlocks(parsed, preprocessed.metadataByPlaceholder);
+        const contentJson = validateAndCleanDocument(normalized);
+        const contentText = normalizeContentText(getPreviewTextFromDocument(contentJson));
         return { contentJson, contentText };
     }
     catch (error) {
         throw new DinoxError('Failed to convert markdown to TipTap JSON', { cause: error });
     }
-    finally {
-        editor?.destroy();
-    }
 }
+export { createAudioNodeFromLink, createFileNodeFromLink, createImageNodeWithMetadata, createVideoNodeFromLink, inferMimeTypeFromHref, normalizeFileBlockAttrs, };

package/dist/utils/tiptapMarkdownSchema.d.ts

@@ -0,0 +1,37 @@
+import { MarkdownManager } from '@tiptap/markdown';
+import { Node } from '@tiptap/core';
+import { AudioMarkdownAttrs, DinoxImageAttrs } from './tiptapMarkdownSchemaUtils.js';
+export declare function createDinoxMarkdownExtensions(): (Node<any, any> | Node<import("@tiptap/extension-image").ImageOptions, any> | Node<import("@tiptap/extension-paragraph").ParagraphOptions, any> | import("@tiptap/core").Mark<import("@tiptap/extension-bold").BoldOptions, any> | Node<import("@tiptap/extension-code-block").CodeBlockOptions, any> | import("@tiptap/core").Mark<import("@tiptap/extension-link").LinkOptions, any> | Node<import("@tiptap/extension-hard-break").HardBreakOptions, any> | Node<import("@tiptap/extension-heading").HeadingOptions, any> | Node<import("@tiptap/extension-list").BulletListOptions, any> | Node<import("@tiptap/extension-list").ListItemOptions, any> | Node<import("@tiptap/extension-list").TaskListOptions, any> | Node<import("@tiptap/extension-list").TaskItemOptions, any> | import("@tiptap/core").Mark<import("@tiptap/extension-highlight").HighlightOptions, any> | Node<import("@tiptap/extension-horizontal-rule").HorizontalRuleOptions, any> | import("@tiptap/core").Extension<import("@tiptap/extension-mathematics").MathematicsOptions, any> | Node<import("@tiptap/extension-table").TableOptions, any>)[];
+export declare function getDinoxMarkdownManager(): MarkdownManager;
+export declare function createVideoNodeFromLink(input: {
+    href: string;
+    label: string;
+    resourceId?: string | null;
+}): {
+    type: string;
+    attrs: import("./tiptapMarkdownSchemaUtils.js").VideoMarkdownAttrs;
+};
+export declare function createAudioNodeFromLink(input: {
+    href: string;
+    label: string;
+    resourceId?: string | null;
+}): {
+    type: string;
+    attrs: AudioMarkdownAttrs;
+};
+export declare function createFileNodeFromLink(input: {
+    href: string;
+    label: string;
+    resourceId?: string | null;
+}): {
+    type: string;
+    attrs: import("./tiptapMarkdownSchemaUtils.js").FileBlockAttrs;
+};
+export declare function createImageNodeWithMetadata(attrs: DinoxImageAttrs, metadata: {
+    resourceId?: string | null;
+    widthPercent?: number | null;
+}): {
+    type: string;
+    attrs: DinoxImageAttrs;
+};
+export type { AudioMarkdownAttrs };