@mintlify/common 1.0.447 → 1.0.449

package/dist/rss/index.d.ts

@@ -1,9 +1,12 @@
-import type { FrontmatterContent, Root, RootContent } from 'mdast';
+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;
 export type UpdateMDXComponent = MdxJsxFlowElement;
 export declare const isFrontmatter: (node: RootContent | undefined) => node is FrontmatterContent;
 export declare const isUpdate: (node: RootContent | undefined) => node is UpdateMDXComponent;
+export declare const isHeading: (node: RootContent | undefined) => node is Heading;
+export declare const isNormalMarkdown: (node: RootContent | undefined) => node is RootContent;
 export declare const containsUpdates: (tree: Root) => boolean;
 export declare const getTags: (node: UpdateMDXComponent) => string[] | undefined;
 export declare const getRssPropsData: (updateComponent: UpdateMDXComponent) => {
@@ -16,3 +19,19 @@ export declare const compareUpdates: ({ newTree, previousTree, }: {
     newTree: Root;
     previousTree: Root;
 }) => UpdateMDXComponent[];
+export declare const matchRSSTitle: (node: MdxJsxFlowElement, title: string) => boolean;
+export declare const splitChildrenAtHeadings: (children: RootContent[]) => RootContent[][];
+export declare const getMarkdownHeadingProps: (heading: Parent) => {
+    title: string | undefined;
+    anchor: string | undefined;
+};
+export declare const updateGroupToRSSItemV2: ({ group, date, }: {
+    group: RootContent[];
+    date?: string;
+}) => RSSItemV2 | undefined;
+export declare const getNewContent: (newUpdateComponents: UpdateMDXComponent[]) => RSSItemV2[];
+export declare const getNewMarkdownUpdates: ({ newTree, previousTree, previousUpdates, }: {
+    newTree: Root;
+    previousTree: Root;
+    previousUpdates: RSSItemV2[];
+}) => RSSItemV2[];

package/dist/rss/index.js

@@ -1,3 +1,5 @@
+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) => {
@@ -6,6 +8,22 @@ export const isFrontmatter = (node) => {
 export const isUpdate = (node) => {
     return (node === null || node === void 0 ? void 0 : node.type) === 'mdxJsxFlowElement' && node.name === 'Update';
 };
+export const isHeading = (node) => {
+    if (!node) {
+        return false;
+    }
+    return node.type === 'heading';
+};
+export const isNormalMarkdown = (node) => {
+    if (!node) {
+        return false;
+    }
+    return (node.type !== 'mdxJsxFlowElement' &&
+        node.type !== 'mdxJsxTextElement' &&
+        node.type !== 'html' &&
+        node.type !== 'code' &&
+        node.type !== 'inlineCode');
+};
 export const containsUpdates = (tree) => {
     return tree.children.some((child) => isUpdate(child));
 };
@@ -63,3 +81,96 @@ export const compareUpdates = ({ newTree, previousTree, }) => {
     });
     return newUpdates;
 };
+export const matchRSSTitle = (node, title) => {
+    const { rssTitle } = getRssPropsData(node);
+    const label = getUpdateTitle(node);
+    const nodeTitle = label || rssTitle;
+    return nodeTitle === title;
+};
+export const splitChildrenAtHeadings = (children) => {
+    return children.reduce((acc, child) => {
+        if (isHeading(child)) {
+            acc.push([child]);
+        }
+        else {
+            if (isNormalMarkdown(child)) {
+                if (acc.length === 0) {
+                    acc.push([child]);
+                }
+                else {
+                    const lastGroup = acc[acc.length - 1];
+                    if (lastGroup) {
+                        lastGroup.push(child);
+                    }
+                }
+            }
+        }
+        return acc;
+    }, []);
+};
+export const getMarkdownHeadingProps = (heading) => {
+    const headingContent = heading.children[0];
+    let title = undefined;
+    let anchor = undefined;
+    if ((headingContent === null || headingContent === void 0 ? void 0 : headingContent.type) === 'text') {
+        title = headingContent.value;
+    }
+    if (title) {
+        anchor = slugify(title);
+    }
+    return { title, anchor };
+};
+export const updateGroupToRSSItemV2 = ({ group, date, }) => {
+    const dateToUse = date || new Date().toISOString();
+    const heading = group[0];
+    if (!heading || !isHeading(heading)) {
+        return undefined;
+    }
+    const { title, anchor } = getMarkdownHeadingProps(heading);
+    const content = group.slice(1);
+    const contentString = stringifyTree({
+        type: 'root',
+        children: content,
+    });
+    if (!title || !anchor) {
+        return undefined;
+    }
+    return { title, date: dateToUse, anchor, content: contentString };
+};
+export const getNewContent = (newUpdateComponents) => {
+    const newUpdates = [];
+    for (const component of newUpdateComponents) {
+        const children = component.children;
+        const updatesByHeading = splitChildrenAtHeadings(children);
+        for (const group of updatesByHeading) {
+            const newUpdate = updateGroupToRSSItemV2({ group });
+            if (newUpdate) {
+                newUpdates.push(newUpdate);
+            }
+        }
+    }
+    return newUpdates;
+};
+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);
+    const actuallyNewUpdates = [];
+    for (const group of newUpdates) {
+        const newUpdate = updateGroupToRSSItemV2({ group });
+        if (newUpdate && !previousUpdates.find((update) => update.title === newUpdate.title)) {
+            actuallyNewUpdates.push(newUpdate);
+        }
+    }
+    return actuallyNewUpdates;
+};