@mintlify/validation 0.1.739 → 0.1.741

package/dist/editor-navigation/conversion/common.js

@@ -1,3 +1,4 @@
+import { compareNodes } from '../order.js';
 import { generateNodeId } from '../utils.js';
 export const createIdGenerator = () => {
     let counter = 0;
@@ -35,7 +36,7 @@ export function buildChildrenMap(tree) {
         childrenMap.set(node.parent, children);
     });
     childrenMap.forEach((children) => {
-        children.sort((a, b) => a.order - b.order);
+        children.sort(compareNodes);
     });
     return childrenMap;
 }

package/dist/editor-navigation/conversion/docsjson-to-tree.js

@@ -1,4 +1,5 @@
 import traverse from 'neotraverse';
+import { compareNodes } from '../order.js';
 import { isGlobalNode } from '../schema.js';
 import { createIdGenerator, isProductConfig, isLanguageConfig, isVersionConfig, isTabConfig, isMenuItemConfig, isDropdownConfig, isAnchorConfig, isGroupConfig, } from './common.js';
 function pickDefined(obj) {
@@ -412,7 +413,7 @@ function reorderGlobalNodesFirst(nodes) {
                 return -1;
             if (!aIsGlobal && bIsGlobal)
                 return 1;
-            return a.order - b.order;
+            return compareNodes(a, b);
         });
         siblings.forEach((node, index) => {
             node.order = index;

package/dist/editor-navigation/index.d.ts

@@ -1,4 +1,5 @@
 export * from './types.js';
 export * from './utils.js';
 export * from './schema.js';
+export * from './order.js';
 export * from './conversion/index.js';

package/dist/editor-navigation/index.js

@@ -1,4 +1,5 @@
 export * from './types.js';
 export * from './utils.js';
 export * from './schema.js';
+export * from './order.js';
 export * from './conversion/index.js';

package/dist/editor-navigation/order.d.ts

@@ -0,0 +1,17 @@
+import { generateKeyBetween, generateNKeysBetween } from 'fractional-indexing';
+import type { NavigationOrder } from './types.js';
+export { generateKeyBetween, generateNKeysBetween };
+type OrderedNode = {
+    id: string;
+    order: NavigationOrder;
+};
+type OrderedTreeNode = OrderedNode & {
+    parent: string | 0;
+};
+type WithNavigationOrder<T extends OrderedNode> = Omit<T, 'order'> & {
+    order: NavigationOrder;
+};
+export declare function compareNodes(a: OrderedNode, b: OrderedNode): number;
+export declare function sortByOrder<T extends OrderedNode>(nodes: readonly T[]): T[];
+export declare function normalizeTreeOrder<T extends OrderedTreeNode>(tree: readonly T[]): WithNavigationOrder<T>[];
+export declare function alignTreeOrderKeys<T extends OrderedTreeNode>(tree: readonly T[], reference: readonly OrderedTreeNode[]): WithNavigationOrder<T>[];

package/dist/editor-navigation/order.js

@@ -0,0 +1,98 @@
+import { generateKeyBetween, generateNKeysBetween } from 'fractional-indexing';
+export { generateKeyBetween, generateNKeysBetween };
+function compareOrder(a, b) {
+    if (typeof a === 'number' && typeof b === 'number')
+        return a - b;
+    if (typeof a === 'number')
+        return -1;
+    if (typeof b === 'number')
+        return 1;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+export function compareNodes(a, b) {
+    const byOrder = compareOrder(a.order, b.order);
+    if (byOrder !== 0)
+        return byOrder;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+export function sortByOrder(nodes) {
+    return [...nodes].sort(compareNodes);
+}
+function groupByParent(nodes) {
+    var _a;
+    const byParent = new Map();
+    for (const node of nodes) {
+        const group = (_a = byParent.get(node.parent)) !== null && _a !== void 0 ? _a : [];
+        group.push(node);
+        byParent.set(node.parent, group);
+    }
+    return byParent;
+}
+function applyOrderUpdates(tree, orderById) {
+    if (orderById.size === 0)
+        return tree;
+    return tree.map((node) => {
+        const order = orderById.get(node.id);
+        return order === undefined ? node : Object.assign(Object.assign({}, node), { order });
+    });
+}
+export function normalizeTreeOrder(tree) {
+    const orderById = new Map();
+    for (const group of groupByParent(tree).values()) {
+        if (!group.some((node) => typeof node.order === 'number'))
+            continue;
+        const sorted = sortByOrder(group);
+        const keys = generateNKeysBetween(null, null, sorted.length);
+        sorted.forEach((node, index) => {
+            const key = keys[index];
+            if (key !== undefined && node.order !== key)
+                orderById.set(node.id, key);
+        });
+    }
+    return applyOrderUpdates(tree, orderById);
+}
+export function alignTreeOrderKeys(tree, reference) {
+    var _a, _b, _c;
+    const referenceKeys = new Map();
+    for (const node of reference) {
+        if (typeof node.order !== 'string')
+            continue;
+        referenceKeys.set(`${node.parent}::${node.id}`, node.order);
+    }
+    const orderById = new Map();
+    for (const group of groupByParent(tree).values()) {
+        const sorted = sortByOrder(group);
+        const keys = sorted.map(() => null);
+        let lastReused = null;
+        sorted.forEach((node, index) => {
+            const key = referenceKeys.get(`${node.parent}::${node.id}`);
+            if (key !== undefined && (lastReused === null || key > lastReused)) {
+                keys[index] = key;
+                lastReused = key;
+            }
+        });
+        let start = 0;
+        while (start < sorted.length) {
+            if (keys[start] !== null) {
+                start++;
+                continue;
+            }
+            let end = start;
+            while (end < sorted.length && keys[end] === null)
+                end++;
+            const before = start > 0 ? ((_a = keys[start - 1]) !== null && _a !== void 0 ? _a : null) : null;
+            const after = end < sorted.length ? ((_b = keys[end]) !== null && _b !== void 0 ? _b : null) : null;
+            const filled = generateNKeysBetween(before, after, end - start);
+            for (let i = start; i < end; i++)
+                keys[i] = (_c = filled[i - start]) !== null && _c !== void 0 ? _c : null;
+            start = end;
+        }
+        sorted.forEach((node, index) => {
+            var _a;
+            const key = (_a = keys[index]) !== null && _a !== void 0 ? _a : null;
+            if (key !== null && node.order !== key)
+                orderById.set(node.id, key);
+        });
+    }
+    return applyOrderUpdates(tree, orderById);
+}

package/dist/editor-navigation/types.d.ts

@@ -10,6 +10,7 @@ export type NavigationNodeType = DivisionType | ContentType | FilesystemType;
 export declare const ROOT_NODE: "root";
 export type ROOT_NODE_TYPE = typeof ROOT_NODE;
 export type ParentNodeType = NavigationNodeType | ROOT_NODE_TYPE;
+export type NavigationOrder = number | string;
 export interface BaseNavigationNode<TData> {
     id: string;
     parent: string | 0;