@mintlify/common 1.0.648 → 1.0.650

package/dist/rss/constants.d.ts

@@ -0,0 +1 @@
+export declare const UPDATE_MAX = 15;

package/dist/rss/constants.js

@@ -0,0 +1 @@
+export const UPDATE_MAX = 15;

package/dist/rss/dates.d.ts

@@ -0,0 +1,4 @@
+import type { RootContent } from 'mdast';
+import type { UpdateMDXComponent } from './index.js';
+export declare const getDateForNode: (node: RootContent, lineBlame: Record<number, string>) => string;
+export declare const getMostRepresentativeDate: (updateComponent: UpdateMDXComponent, lineBlame: Record<number, string>, defaultDate: string) => string;

package/dist/rss/dates.js

@@ -0,0 +1,49 @@
+export const getDateForNode = (node, lineBlame) => {
+    if (!node.position) {
+        return new Date().toISOString();
+    }
+    const startLine = node.position.start.line;
+    const blameDate = lineBlame[startLine];
+    if (blameDate) {
+        const parsedDate = new Date(blameDate);
+        if (!isNaN(parsedDate.getTime())) {
+            return parsedDate.toISOString();
+        }
+    }
+    return new Date().toISOString();
+};
+export const getMostRepresentativeDate = (updateComponent, lineBlame, defaultDate) => {
+    const dates = [];
+    const collectDates = (nodes) => {
+        for (const node of nodes) {
+            if (node.type !== 'heading' && node.position) {
+                const nodeDate = getDateForNode(node, lineBlame);
+                dates.push(nodeDate);
+            }
+            if ('children' in node && Array.isArray(node.children) && node.children.length > 0) {
+                collectDates(node.children);
+            }
+        }
+    };
+    collectDates(updateComponent.children);
+    if (dates.length === 0) {
+        return defaultDate;
+    }
+    const dateCounts = new Map();
+    for (const date of dates) {
+        dateCounts.set(date, (dateCounts.get(date) || 0) + 1);
+    }
+    let mostCommonDate = defaultDate;
+    let maxCount = 0;
+    for (const [date, count] of dateCounts.entries()) {
+        if (count > maxCount) {
+            maxCount = count;
+            mostCommonDate = date;
+        }
+    }
+    const threshold = dates.length * 0.9;
+    if (maxCount >= threshold) {
+        return mostCommonDate;
+    }
+    return defaultDate;
+};

package/dist/rss/encodeContentAsHtml.d.ts

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

package/dist/rss/encodeContentAsHtml.js

@@ -0,0 +1,40 @@
+import { fromHtml } from 'hast-util-from-html';
+import rehypeStringify from 'rehype-stringify';
+import remarkGfm from 'remark-gfm';
+import remarkParse from 'remark-parse';
+import remarkRehype from 'remark-rehype';
+import { unified } from 'unified';
+import { visit } from 'unist-util-visit';
+const DANGEROUS_TAGS = ['script', 'iframe', 'object', 'embed', 'style'];
+const rehypeRaw = () => {
+    return (tree) => {
+        visit(tree, 'raw', (raw, index, parent) => {
+            if ('value' in raw && parent && index !== undefined) {
+                const rawAst = fromHtml(raw.value, { fragment: true });
+                parent.children.splice(index, 1, ...rawAst.children);
+            }
+        });
+    };
+};
+const rehypeSanitizeDangerous = () => {
+    return (tree) => {
+        visit(tree, 'element', (node, index, parent) => {
+            if (parent && typeof index === 'number' && DANGEROUS_TAGS.includes(node.tagName)) {
+                parent.children.splice(index, 1);
+                return ['skip', index];
+            }
+        });
+    };
+};
+export const encodeContentAsHtml = (content) => {
+    const html = unified()
+        .use(remarkParse)
+        .use(remarkGfm)
+        .use(remarkRehype, { allowDangerousHtml: true })
+        .use(rehypeRaw)
+        .use(rehypeSanitizeDangerous)
+        .use(rehypeStringify, { allowDangerousHtml: true })
+        .processSync(content)
+        .toString();
+    return html;
+};

package/dist/rss/enhanceSnippetsWithImportNames.d.ts

@@ -0,0 +1,3 @@
+import type { Root } from 'mdast';
+import type { RssSnippetFile } from '../types/rss.js';
+export declare const enhanceSnippetsWithImportNames: (ast: Root, snippets: RssSnippetFile[]) => Promise<RssSnippetFile[]>;

package/dist/rss/enhanceSnippetsWithImportNames.js

@@ -0,0 +1,28 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { findAndRemoveImports } from '../mdx/snippets/findAndRemoveImports.js';
+export const enhanceSnippetsWithImportNames = (ast, snippets) => __awaiter(void 0, void 0, void 0, function* () {
+    const { importMap } = yield findAndRemoveImports(structuredClone(ast));
+    return snippets.map((snippet) => {
+        if (snippet.importNames && snippet.importNames.length > 0) {
+            return snippet;
+        }
+        let importSpecifiers = importMap[snippet.path];
+        if (!importSpecifiers) {
+            const pathWithSlash = snippet.path.startsWith('/') ? snippet.path : `/${snippet.path}`;
+            const pathWithoutSlash = snippet.path.startsWith('/') ? snippet.path.slice(1) : snippet.path;
+            importSpecifiers = importMap[pathWithSlash] || importMap[pathWithoutSlash];
+        }
+        if (importSpecifiers && importSpecifiers.length > 0) {
+            return Object.assign(Object.assign({}, snippet), { importNames: importSpecifiers.map((spec) => spec.name) });
+        }
+        return snippet;
+    });
+});

package/dist/rss/getV4FeedUpdates.d.ts

@@ -0,0 +1,2 @@
+import type { SavedRssFileV4, RSSItemV2 } from '../types/rss.js';
+export declare const getV4FeedUpdates: (rssFile: SavedRssFileV4) => Promise<RSSItemV2[]>;

package/dist/rss/getV4FeedUpdates.js

@@ -0,0 +1,53 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getAST } from '../mdx/remark.js';
+import { UPDATE_MAX } from './constants.js';
+import { getDateForNode, getMostRepresentativeDate } from './dates.js';
+import { enhanceSnippetsWithImportNames } from './enhanceSnippetsWithImportNames.js';
+import { isUpdate } from './index.js';
+import { processUpdateNode } from './processUpdateNode.js';
+import { resolveSnippets } from './resolveSnippets.js';
+export const getV4FeedUpdates = (rssFile) => __awaiter(void 0, void 0, void 0, function* () {
+    const { content, lineBlame, snippets } = rssFile;
+    if (!content) {
+        return [];
+    }
+    const effectiveLineBlame = Object.keys(lineBlame).length > 0 ? lineBlame : { 1: new Date().toISOString() };
+    let ast;
+    try {
+        ast = getAST(content);
+    }
+    catch (error) {
+        return [];
+    }
+    if (snippets && snippets.length > 0) {
+        try {
+            const enhancedSnippets = yield enhanceSnippetsWithImportNames(ast, snippets);
+            ast = resolveSnippets(ast, enhancedSnippets);
+        }
+        catch (_a) { }
+    }
+    const updateComponents = ast.children.filter((child) => isUpdate(child));
+    if (updateComponents.length === 0) {
+        return [];
+    }
+    const allUpdates = [];
+    for (const updateComponent of updateComponents) {
+        const componentDate = getDateForNode(updateComponent, effectiveLineBlame);
+        const representativeDate = getMostRepresentativeDate(updateComponent, effectiveLineBlame, componentDate);
+        const updates = processUpdateNode({
+            updateNode: updateComponent,
+            date: representativeDate,
+        });
+        allUpdates.push(...updates);
+    }
+    const limitedUpdates = allUpdates.slice(0, UPDATE_MAX);
+    return limitedUpdates;
+});

package/dist/rss/index.d.ts

@@ -1,7 +1,6 @@
 import type { FrontmatterContent, Heading, Parent, Root, RootContent } from 'mdast';
 import { MdxJsxFlowElement } from 'mdast-util-mdx-jsx';
-import { RSSItemV2 } from '../types/rss.js';
-export declare const UPDATE_MAX = 15;
+import { RSSItemV2, SavedRssFileV4, SavedRssFileWithContent } from '../types/rss.js';
 export type UpdateMDXComponent = MdxJsxFlowElement;
 export declare const isFrontmatter: (node: RootContent | undefined) => node is FrontmatterContent;
 export declare const isUpdate: (node: RootContent | undefined) => node is UpdateMDXComponent;
@@ -53,3 +52,9 @@ export declare const processUpdatePerMarkdownGroup: ({ updateNode, date, updates
     date: string;
     updatesByMarkdown: RootContent[][];
 }) => RSSItemV2[];
+export declare const isRSSFileV4: (rssFile: SavedRssFileWithContent | SavedRssFileV4) => rssFile is SavedRssFileV4;
+export { enhanceSnippetsWithImportNames } from './enhanceSnippetsWithImportNames.js';
+export { getV4FeedUpdates } from './getV4FeedUpdates.js';
+export { resolveSnippets } from './resolveSnippets.js';
+export { encodeContentAsHtml } from './encodeContentAsHtml.js';
+export { UPDATE_MAX } from './constants.js';

package/dist/rss/index.js

@@ -1,7 +1,6 @@
 import slugify from '@sindresorhus/slugify';
 import { stringifyTree } from '../mdx/index.js';
 import { getArrayExpressionStringProperties, getObjectExpressionStringProperty, } from '../mdx/utils.js';
-export const UPDATE_MAX = 15;
 export const isFrontmatter = (node) => {
     return (node === null || node === void 0 ? void 0 : node.type) === 'yaml';
 };
@@ -14,15 +13,49 @@ export const isHeading = (node) => {
     }
     return node.type === 'heading';
 };
+// Standard HTML tags that should be included in RSS feeds
+const STANDARD_HTML_TAGS = new Set([
+    'table',
+    'tr',
+    'td',
+    'th',
+    'thead',
+    'tbody',
+    'tfoot',
+    'p',
+    'div',
+    'span',
+    'a',
+    'br',
+    'hr',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'ul',
+    'ol',
+    'li',
+    'strong',
+    'em',
+    'b',
+    'i',
+    'u',
+    'img',
+    'figure',
+    'figcaption',
+    'blockquote',
+    'pre',
+]);
 export const isNormalMarkdown = (node) => {
     if (!node) {
         return false;
     }
-    return (node.type !== 'mdxJsxFlowElement' &&
-        node.type !== 'mdxJsxTextElement' &&
-        node.type !== 'html' &&
-        node.type !== 'code' &&
-        node.type !== 'inlineCode');
+    if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {
+        return STANDARD_HTML_TAGS.has(node.name || '');
+    }
+    return node.type !== 'code' && node.type !== 'inlineCode';
 };
 export const containsUpdates = (tree) => {
     return tree.children.some((child) => isUpdate(child));
@@ -120,6 +153,42 @@ export const getMarkdownHeadingProps = (heading) => {
     }
     return { title, anchor };
 };
+const jsxToHtml = (node) => {
+    const tagName = node.name || 'div';
+    const attrs = node.attributes
+        .filter((attr) => attr.type === 'mdxJsxAttribute' && typeof attr.value === 'string')
+        .map((attr) => {
+        if (attr.type === 'mdxJsxAttribute' && attr.name !== 'className') {
+            return `${attr.name}="${attr.value}"`;
+        }
+        return '';
+    })
+        .filter(Boolean)
+        .join(' ');
+    const attrsStr = attrs ? ` ${attrs}` : '';
+    const childrenStr = node.children
+        .map((child) => {
+        if (child.type === 'mdxJsxFlowElement' || child.type === 'mdxJsxTextElement') {
+            return jsxToHtml(child);
+        }
+        if (child.type === 'text') {
+            return child.value;
+        }
+        return stringifyTree({ type: 'root', children: [child] }).trim();
+    })
+        .join('');
+    return `<${tagName}${attrsStr}>${childrenStr}</${tagName}>`;
+};
+const stringifyTreeForRSS = (tree) => {
+    return tree.children
+        .map((child) => {
+        if (child.type === 'mdxJsxFlowElement' || child.type === 'mdxJsxTextElement') {
+            return jsxToHtml(child);
+        }
+        return stringifyTree({ type: 'root', children: [child] }).trim();
+    })
+        .join('\n\n');
+};
 export const updateGroupToRSSItemV2 = ({ group, date, }) => {
     const dateToUse = date || new Date().toISOString();
     const heading = group[0];
@@ -128,7 +197,7 @@ export const updateGroupToRSSItemV2 = ({ group, date, }) => {
     }
     const { title, anchor } = getMarkdownHeadingProps(heading);
     const content = group.slice(1);
-    const contentString = stringifyTree({
+    const contentString = stringifyTreeForRSS({
         type: 'root',
         children: content,
     });
@@ -155,13 +224,11 @@ export const getNewMarkdownUpdates = ({ newTree, previousTree, previousUpdates,
     const firstUpdateInNewTree = newTree.children.find(isUpdate);
     const firstUpdateInPreviousTree = previousTree.children.find(isUpdate);
     if (!isUpdate(firstUpdateInNewTree) || !isUpdate(firstUpdateInPreviousTree)) {
-        // no last updates found to compare
         return [];
     }
     const firstUpdateTitleInNewTree = getUpdateTitle(firstUpdateInNewTree);
     const firstUpdateTitleInPreviousTree = getUpdateTitle(firstUpdateInPreviousTree);
     if (firstUpdateTitleInNewTree !== firstUpdateTitleInPreviousTree) {
-        // last update component has changed
         return [];
     }
     const newUpdates = splitChildrenAtHeadings(firstUpdateInNewTree.children);
@@ -191,6 +258,7 @@ export const containsMarkdownHeading = (updateNode, title) => {
         child.children.some((child) => child.type === 'text' && child.value.includes(title)));
     return containsHeading;
 };
+// soon to be deprecated, use processUpdateNode.ts instead
 export const processUpdateNode = ({ updateNode, date, }) => {
     const updates = [];
     const nowOrOldDate = date || new Date().toISOString();
@@ -230,7 +298,7 @@ export const processUpdatePerNode = ({ updateNode, date, title, description, })
     const anchor = slugify(label);
     const categories = getTags(updateNode);
     const contentNodes = updateNode.children.filter((child) => isNormalMarkdown(child));
-    const contentString = stringifyTree({
+    const contentString = stringifyTreeForRSS({
         type: 'root',
         children: contentNodes,
     });
@@ -256,3 +324,11 @@ export const processUpdatePerMarkdownGroup = ({ updateNode, date, updatesByMarkd
     }
     return updates;
 };
+export const isRSSFileV4 = (rssFile) => {
+    return rssFile.version === 'v4';
+};
+export { enhanceSnippetsWithImportNames } from './enhanceSnippetsWithImportNames.js';
+export { getV4FeedUpdates } from './getV4FeedUpdates.js';
+export { resolveSnippets } from './resolveSnippets.js';
+export { encodeContentAsHtml } from './encodeContentAsHtml.js';
+export { UPDATE_MAX } from './constants.js';

package/dist/rss/processUpdateNode.d.ts

@@ -0,0 +1,6 @@
+import { RSSItemV2 } from '../types/rss.js';
+import { UpdateMDXComponent } from './index.js';
+export declare const processUpdateNode: ({ updateNode, date, }: {
+    updateNode: UpdateMDXComponent;
+    date: string;
+}) => RSSItemV2[];

package/dist/rss/processUpdateNode.js

@@ -0,0 +1,10 @@
+import { getRssPropsData, processUpdatePerNode } from './index.js';
+export const processUpdateNode = ({ updateNode, date, }) => {
+    const { rssTitle, rssDescription } = getRssPropsData(updateNode);
+    return processUpdatePerNode({
+        updateNode,
+        date,
+        title: rssTitle,
+        description: rssDescription,
+    });
+};

package/dist/rss/resolveSnippets.d.ts

@@ -0,0 +1,3 @@
+import type { Root } from 'mdast';
+import { RssSnippetFile } from '../types/rss.js';
+export declare const resolveSnippets: (ast: Root, snippets: RssSnippetFile[]) => Root;

package/dist/rss/resolveSnippets.js

@@ -0,0 +1,60 @@
+import { getAST } from '../mdx/remark.js';
+export const resolveSnippets = (ast, snippets) => {
+    const snippetTreeMap = buildSnippetTreeMap(snippets);
+    const newChildren = [];
+    for (const child of ast.children) {
+        if (child.type === 'mdxJsxFlowElement' && 'name' in child && child.name) {
+            const componentName = String(child.name);
+            if (componentName === 'Snippet' && 'attributes' in child) {
+                const fileAttr = child.attributes.find((attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'file');
+                if (fileAttr && fileAttr.value) {
+                    const fileName = typeof fileAttr.value === 'string' ? fileAttr.value : fileAttr.value.value;
+                    if (snippetTreeMap[fileName]) {
+                        const snippetAst = snippetTreeMap[fileName];
+                        newChildren.push(...snippetAst.children);
+                        continue;
+                    }
+                    const fileNameOnly = fileName.split('/').pop();
+                    if (fileNameOnly && snippetTreeMap[fileNameOnly]) {
+                        const snippetAst = snippetTreeMap[fileNameOnly];
+                        newChildren.push(...snippetAst.children);
+                        continue;
+                    }
+                }
+            }
+            if (snippetTreeMap[componentName]) {
+                const snippetAst = snippetTreeMap[componentName];
+                newChildren.push(...snippetAst.children);
+                continue;
+            }
+            newChildren.push(child);
+        }
+        else {
+            newChildren.push(child);
+        }
+    }
+    ast.children = newChildren;
+    return ast;
+};
+const buildSnippetTreeMap = (snippets) => {
+    const map = {};
+    for (const snippet of snippets) {
+        try {
+            const snippetAst = getAST(snippet.content);
+            if ('importNames' in snippet && snippet.importNames && snippet.importNames.length > 0) {
+                for (const importName of snippet.importNames) {
+                    map[importName] = snippetAst;
+                }
+            }
+            map[snippet.path] = snippetAst;
+            const filename = snippet.path.split('/').pop();
+            if (filename && filename !== snippet.path) {
+                map[filename] = snippetAst;
+            }
+        }
+        catch (error) {
+            console.error('Failed to parse snippet:', snippet.path, error);
+        }
+    }
+    return map;
+};