@mintlify/validation 0.1.638 → 0.1.639

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

@@ -0,0 +1,264 @@
+import { isGlobalNode } from '../schema.js';
+import { buildChildrenMap, mapNodesOfType, assignIfPresent, TAB_NODE_DATA_FIELDS, ANCHOR_NODE_DATA_FIELDS, LANGUAGE_NODE_DATA_FIELDS, VERSION_NODE_DATA_FIELDS, DROPDOWN_NODE_DATA_FIELDS, PRODUCT_NODE_DATA_FIELDS, GROUP_NODE_DATA_FIELDS, MENU_ITEM_NODE_DATA_FIELDS, } from './common.js';
+function nodesToPages(nodes, childrenMap) {
+    return nodes.map((node) => {
+        if (node.type === 'group') {
+            const groupChildren = childrenMap.get(node.id) || [];
+            const baseConfig = { group: node.data.group };
+            assignIfPresent(baseConfig, node.data, GROUP_NODE_DATA_FIELDS);
+            if ((node.data.openapi !== undefined || node.data.asyncapi !== undefined) &&
+                !groupChildren.length) {
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- groups default `pages` to an empty array, so we can cast with pages being undefined
+                return Object.assign(Object.assign({}, baseConfig), { group: node.data.group });
+            }
+            return Object.assign(Object.assign({}, baseConfig), { group: node.data.group, pages: nodesToPages(groupChildren, childrenMap) });
+        }
+        if (node.type === 'page') {
+            return node.data.href;
+        }
+        return '';
+    });
+}
+function nodesToGroups(nodes, childrenMap) {
+    return mapNodesOfType(nodes, 'group', childrenMap, (node, map) => {
+        const groupChildren = map.get(node.id) || [];
+        const baseConfig = { group: node.data.group };
+        assignIfPresent(baseConfig, node.data, GROUP_NODE_DATA_FIELDS);
+        if ((node.data.openapi !== undefined || node.data.asyncapi !== undefined) &&
+            !groupChildren.length) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- groups default `pages` to an empty array, so we can cast with pages being undefined
+            return Object.assign(Object.assign({}, baseConfig), { group: node.data.group });
+        }
+        return Object.assign(Object.assign({}, baseConfig), { group: node.data.group, pages: nodesToPages(groupChildren, map) });
+    });
+}
+function getGlobalChildren(childrenMap, nodeId) {
+    const children = childrenMap.get(nodeId) || [];
+    return children.filter(isGlobalNode);
+}
+function getRegularChildren(childrenMap, nodeId) {
+    const children = childrenMap.get(nodeId) || [];
+    return children.filter((child) => !isGlobalNode(child));
+}
+function nodesToGlobalConfig(globalChildren) {
+    if (globalChildren.length === 0)
+        return undefined;
+    const globalConfig = {};
+    const languages = globalChildren.filter((n) => n.type === 'language');
+    const versions = globalChildren.filter((n) => n.type === 'version');
+    const tabs = globalChildren.filter((n) => n.type === 'tab');
+    const dropdowns = globalChildren.filter((n) => n.type === 'dropdown');
+    const anchors = globalChildren.filter((n) => n.type === 'anchor');
+    const products = globalChildren.filter((n) => n.type === 'product');
+    if (languages.length > 0) {
+        globalConfig.languages = languages.map((node) => (Object.assign(Object.assign(Object.assign({ language: node.data.language }, (node.data.hidden !== undefined && { hidden: node.data.hidden })), (node.data.default !== undefined && { default: node.data.default })), { href: node.data.href || '' })));
+    }
+    if (versions.length > 0) {
+        globalConfig.versions = versions.map((node) => (Object.assign(Object.assign(Object.assign({ version: node.data.version }, (node.data.hidden !== undefined && { hidden: node.data.hidden })), (node.data.default !== undefined && { default: node.data.default })), { href: node.data.href || '' })));
+    }
+    if (tabs.length > 0) {
+        globalConfig.tabs = tabs.map((node) => (Object.assign(Object.assign(Object.assign({ tab: node.data.tab }, (node.data.icon !== undefined && { icon: node.data.icon })), (node.data.hidden !== undefined && { hidden: node.data.hidden })), { href: node.data.href || '' })));
+    }
+    if (dropdowns.length > 0) {
+        globalConfig.dropdowns = dropdowns.map((node) => (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ dropdown: node.data.dropdown }, (node.data.icon !== undefined && { icon: node.data.icon })), (node.data.color !== undefined && { color: node.data.color })), (node.data.description !== undefined && { description: node.data.description })), (node.data.hidden !== undefined && { hidden: node.data.hidden })), { href: node.data.href || '' })));
+    }
+    if (anchors.length > 0) {
+        globalConfig.anchors = anchors.map((node) => (Object.assign(Object.assign(Object.assign(Object.assign({ anchor: node.data.anchor }, (node.data.icon !== undefined && { icon: node.data.icon })), (node.data.color !== undefined && { color: node.data.color })), (node.data.hidden !== undefined && { hidden: node.data.hidden })), { href: node.data.href || '' })));
+    }
+    if (products.length > 0) {
+        globalConfig.products = products.map((node) => (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ product: node.data.product }, (node.data.name !== undefined && { name: node.data.name })), (node.data.icon !== undefined && { icon: node.data.icon })), (node.data.color !== undefined && { color: node.data.color })), (node.data.description !== undefined && { description: node.data.description })), (node.data.hidden !== undefined && { hidden: node.data.hidden })), { href: node.data.href || '' })));
+    }
+    return Object.keys(globalConfig).length > 0 ? globalConfig : undefined;
+}
+function buildChildNavigation(node, childrenMap) {
+    const regularChildren = getRegularChildren(childrenMap, node.id);
+    if (regularChildren.length === 0) {
+        return {};
+    }
+    const firstChild = regularChildren[0];
+    if (!firstChild) {
+        return {};
+    }
+    const childType = firstChild.type;
+    const children = regularChildren;
+    switch (childType) {
+        case 'product':
+            return { products: nodesToProducts(children, childrenMap) };
+        case 'language':
+            return { languages: nodesToLanguages(children, childrenMap) };
+        case 'version':
+            return { versions: nodesToVersions(children, childrenMap) };
+        case 'tab':
+            return { tabs: nodesToTabs(children, childrenMap) };
+        case 'dropdown':
+            return { dropdowns: nodesToDropdowns(children, childrenMap) };
+        case 'anchor':
+            return { anchors: nodesToAnchors(children, childrenMap) };
+        case 'item':
+            return { menu: nodesToMenuItems(children, childrenMap) };
+        case 'group':
+            if (firstChild.data.fromPages) {
+                return { pages: nodesToPages(children, childrenMap) };
+            }
+            const hasPageSibling = children.some((child) => child.type === 'page');
+            if (hasPageSibling) {
+                return { pages: nodesToPages(children, childrenMap) };
+            }
+            return { groups: nodesToGroups(children, childrenMap) };
+        case 'page':
+            return { pages: nodesToPages(children, childrenMap) };
+        default:
+            return {};
+    }
+}
+function nodesToTabs(nodes, childrenMap) {
+    return mapNodesOfType(nodes, 'tab', childrenMap, (node, map) => {
+        const globalChildren = getGlobalChildren(map, node.id);
+        const globalConfig = nodesToGlobalConfig(globalChildren);
+        const baseConfig = { tab: node.data.tab };
+        assignIfPresent(baseConfig, node.data, TAB_NODE_DATA_FIELDS);
+        if (node.data.href && !node.data.isGlobal) {
+            return Object.assign(Object.assign(Object.assign({}, baseConfig), { tab: node.data.tab, href: node.data.href }), (globalConfig && { global: globalConfig }));
+        }
+        const childNav = buildChildNavigation(node, map);
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, baseConfig), { tab: node.data.tab }), (globalConfig && { global: globalConfig })), childNav);
+    });
+}
+function nodesToAnchors(nodes, childrenMap) {
+    return mapNodesOfType(nodes, 'anchor', childrenMap, (node, map) => {
+        const globalChildren = getGlobalChildren(map, node.id);
+        const globalConfig = nodesToGlobalConfig(globalChildren);
+        const baseConfig = { anchor: node.data.anchor };
+        assignIfPresent(baseConfig, node.data, ANCHOR_NODE_DATA_FIELDS);
+        if (node.data.href && !node.data.isGlobal) {
+            return Object.assign(Object.assign(Object.assign({}, baseConfig), { anchor: node.data.anchor, href: node.data.href }), (globalConfig && { global: globalConfig }));
+        }
+        const childNav = buildChildNavigation(node, map);
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, baseConfig), { anchor: node.data.anchor }), (globalConfig && { global: globalConfig })), childNav);
+    });
+}
+function nodesToLanguages(nodes, childrenMap) {
+    return mapNodesOfType(nodes, 'language', childrenMap, (node, map) => {
+        const globalChildren = getGlobalChildren(map, node.id);
+        const globalConfig = nodesToGlobalConfig(globalChildren);
+        const baseConfig = Object.assign({ language: node.data.language }, (node.data.default !== undefined && { default: node.data.default }));
+        assignIfPresent(baseConfig, node.data, LANGUAGE_NODE_DATA_FIELDS);
+        if (node.data.href && !node.data.isGlobal) {
+            return Object.assign(Object.assign(Object.assign({}, baseConfig), { language: node.data.language, href: node.data.href }), (globalConfig && { global: globalConfig }));
+        }
+        const childNav = buildChildNavigation(node, map);
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, baseConfig), { language: node.data.language }), (globalConfig && { global: globalConfig })), childNav);
+    });
+}
+function nodesToVersions(nodes, childrenMap) {
+    return mapNodesOfType(nodes, 'version', childrenMap, (node, map) => {
+        const globalChildren = getGlobalChildren(map, node.id);
+        const globalConfig = nodesToGlobalConfig(globalChildren);
+        const baseConfig = Object.assign({ version: node.data.version }, (node.data.default !== undefined && { default: node.data.default }));
+        assignIfPresent(baseConfig, node.data, VERSION_NODE_DATA_FIELDS);
+        if (node.data.href && !node.data.isGlobal) {
+            return Object.assign(Object.assign(Object.assign({}, baseConfig), { version: node.data.version, href: node.data.href }), (globalConfig && { global: globalConfig }));
+        }
+        const childNav = buildChildNavigation(node, map);
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, baseConfig), { version: node.data.version }), (globalConfig && { global: globalConfig })), childNav);
+    });
+}
+function nodesToDropdowns(nodes, childrenMap) {
+    return mapNodesOfType(nodes, 'dropdown', childrenMap, (node, map) => {
+        const globalChildren = getGlobalChildren(map, node.id);
+        const globalConfig = nodesToGlobalConfig(globalChildren);
+        const baseConfig = { dropdown: node.data.dropdown };
+        assignIfPresent(baseConfig, node.data, DROPDOWN_NODE_DATA_FIELDS);
+        if (node.data.href && !node.data.isGlobal) {
+            return Object.assign(Object.assign(Object.assign({}, baseConfig), { dropdown: node.data.dropdown, href: node.data.href }), (globalConfig && { global: globalConfig }));
+        }
+        const childNav = buildChildNavigation(node, map);
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, baseConfig), { dropdown: node.data.dropdown }), (globalConfig && { global: globalConfig })), childNav);
+    });
+}
+function nodesToProducts(nodes, childrenMap) {
+    return mapNodesOfType(nodes, 'product', childrenMap, (node, map) => {
+        const globalChildren = getGlobalChildren(map, node.id);
+        const globalConfig = nodesToGlobalConfig(globalChildren);
+        const baseConfig = { product: node.data.product };
+        assignIfPresent(baseConfig, node.data, PRODUCT_NODE_DATA_FIELDS);
+        if (node.data.href && !node.data.isGlobal) {
+            return Object.assign(Object.assign(Object.assign({}, baseConfig), { product: node.data.product, href: node.data.href }), (globalConfig && { global: globalConfig }));
+        }
+        const childNav = buildChildNavigation(node, map);
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, baseConfig), { product: node.data.product }), (globalConfig && { global: globalConfig })), childNav);
+    });
+}
+function nodesToMenuItems(nodes, childrenMap) {
+    return mapNodesOfType(nodes, 'item', childrenMap, (node, map) => {
+        const globalChildren = getGlobalChildren(map, node.id);
+        const globalConfig = nodesToGlobalConfig(globalChildren);
+        const baseConfig = { item: node.data.item };
+        assignIfPresent(baseConfig, node.data, MENU_ITEM_NODE_DATA_FIELDS);
+        if (node.data.href) {
+            return Object.assign(Object.assign(Object.assign({}, baseConfig), { item: node.data.item, href: node.data.href }), (globalConfig && { global: globalConfig }));
+        }
+        const childNav = buildChildNavigation(node, map);
+        return Object.assign(Object.assign(Object.assign(Object.assign({}, baseConfig), { item: node.data.item }), (globalConfig && { global: globalConfig })), childNav);
+    });
+}
+export function navigationTreeToDocsConfig(tree) {
+    const childrenMap = buildChildrenMap(tree);
+    const rootGlobalChildren = getGlobalChildren(childrenMap, 0);
+    const rootRegularChildren = getRegularChildren(childrenMap, 0);
+    const globalConfig = nodesToGlobalConfig(rootGlobalChildren);
+    if (rootRegularChildren.length === 0) {
+        if (globalConfig) {
+            return { global: globalConfig, groups: [] };
+        }
+        return { groups: [] };
+    }
+    const firstChild = rootRegularChildren[0];
+    if (!firstChild) {
+        if (globalConfig) {
+            return { global: globalConfig, groups: [] };
+        }
+        return { groups: [] };
+    }
+    const rootType = firstChild.type;
+    let result;
+    switch (rootType) {
+        case 'product':
+            result = { products: nodesToProducts(rootRegularChildren, childrenMap) };
+            break;
+        case 'language':
+            result = { languages: nodesToLanguages(rootRegularChildren, childrenMap) };
+            break;
+        case 'version':
+            result = { versions: nodesToVersions(rootRegularChildren, childrenMap) };
+            break;
+        case 'tab':
+            result = { tabs: nodesToTabs(rootRegularChildren, childrenMap) };
+            break;
+        case 'dropdown':
+            result = { dropdowns: nodesToDropdowns(rootRegularChildren, childrenMap) };
+            break;
+        case 'anchor':
+            result = { anchors: nodesToAnchors(rootRegularChildren, childrenMap) };
+            break;
+        case 'group': {
+            const hasPageSibling = rootRegularChildren.some((child) => child.type === 'page');
+            if (hasPageSibling) {
+                result = { pages: nodesToPages(rootRegularChildren, childrenMap) };
+            }
+            else {
+                result = { groups: nodesToGroups(rootRegularChildren, childrenMap) };
+            }
+            break;
+        }
+        case 'page':
+            result = { pages: nodesToPages(rootRegularChildren, childrenMap) };
+            break;
+        default:
+            result = { groups: [] };
+    }
+    if (globalConfig) {
+        return Object.assign({ global: globalConfig }, result);
+    }
+    return result;
+}

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

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

package/dist/editor-navigation/index.js

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

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

@@ -0,0 +1,2 @@
+import type { NavigationNode } from './types.js';
+export declare const isGlobalNode: (node: NavigationNode) => boolean;

package/dist/editor-navigation/schema.js

@@ -0,0 +1,13 @@
+export const isGlobalNode = (node) => {
+    switch (node.type) {
+        case 'language':
+        case 'version':
+        case 'tab':
+        case 'dropdown':
+        case 'anchor':
+        case 'product':
+            return node.data.isGlobal === true;
+        default:
+            return false;
+    }
+};

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

@@ -0,0 +1,130 @@
+import { IconType } from '@mintlify/models';
+import { DecoratedPageConfig, BaseDropdownSchema, BaseLanguageSchema, BaseProductSchema, BaseTabSchema, BaseVersionSchema, BaseGroupSchema, BaseAnchorSchema, MenuItemConfig, AsyncApiConfig, OpenApiConfig, IconConfig } from '../mint-config/schemas/v2/properties/index.js';
+export declare const DIVISION_TYPES: readonly ["tab", "dropdown", "anchor", "language", "product", "version", "item"];
+export declare const CONTENT_TYPES: readonly ["page", "group"];
+export type DivisionType = (typeof DIVISION_TYPES)[number];
+export type ContentType = (typeof CONTENT_TYPES)[number];
+export type NavigationNodeType = DivisionType | ContentType;
+export declare const ROOT_NODE: "root";
+export type ROOT_NODE_TYPE = typeof ROOT_NODE;
+export type ParentNodeType = NavigationNodeType | ROOT_NODE_TYPE;
+export interface BaseNavigationNode<TData> {
+    id: string;
+    parent: string | 0;
+    order: number;
+    text: string;
+    type: NavigationNodeType;
+    isHidden?: boolean;
+    data: TData;
+}
+export interface APISchema {
+    asyncapi?: AsyncApiConfig;
+    openapi?: OpenApiConfig;
+}
+export type HrefSchema = {
+    href?: string;
+};
+export type GlobalSchema = {
+    isGlobal?: boolean;
+};
+export interface DropdownNode extends BaseNavigationNode<BaseDropdownSchema & APISchema & HrefSchema & GlobalSchema> {
+    type: 'dropdown';
+}
+export interface VersionNode extends BaseNavigationNode<BaseVersionSchema & APISchema & HrefSchema & GlobalSchema> {
+    type: 'version';
+}
+export interface LanguageNode extends BaseNavigationNode<BaseLanguageSchema & APISchema & HrefSchema & GlobalSchema> {
+    type: 'language';
+}
+export interface TabNode extends BaseNavigationNode<BaseTabSchema & APISchema & HrefSchema & GlobalSchema> {
+    type: 'tab';
+}
+export interface ProductNode extends BaseNavigationNode<BaseProductSchema & APISchema & HrefSchema & GlobalSchema> {
+    type: 'product';
+}
+export interface AnchorNode extends BaseNavigationNode<BaseAnchorSchema & APISchema & HrefSchema & GlobalSchema> {
+    type: 'anchor';
+}
+export interface MenuItemNode extends BaseNavigationNode<MenuItemConfig & APISchema & HrefSchema> {
+    type: 'item';
+}
+export interface GroupNode extends BaseNavigationNode<BaseGroupSchema & APISchema & {
+    fromPages?: boolean;
+}> {
+    type: 'group';
+}
+export interface PageNode extends BaseNavigationNode<DecoratedPageConfig & {
+    ogImageUrl?: string;
+}> {
+    type: 'page';
+}
+export type DivisionNode = DropdownNode | VersionNode | LanguageNode | TabNode | ProductNode | AnchorNode | MenuItemNode;
+export type NavigationNode = DivisionNode | GroupNode | PageNode;
+export type NavigationTree = NavigationNode[];
+export type NodeDataUpdates = {
+    title?: DecoratedPageConfig['title'];
+    description?: DecoratedPageConfig['description'];
+    sidebarTitle?: DecoratedPageConfig['sidebarTitle'];
+    ogImageUrl?: string;
+    tag?: DecoratedPageConfig['tag'];
+    url?: DecoratedPageConfig['url'];
+    keywords?: string[];
+    mode?: DecoratedPageConfig['mode'];
+    icon?: IconConfig;
+    iconType?: IconType;
+    tab?: BaseTabSchema['tab'];
+    anchor?: BaseAnchorSchema['anchor'];
+    group?: BaseGroupSchema['group'];
+    product?: BaseProductSchema['product'];
+    version?: BaseVersionSchema['version'];
+    dropdown?: BaseDropdownSchema['dropdown'];
+    item?: MenuItemConfig['item'];
+    language?: BaseLanguageSchema['language'];
+    hidden?: boolean;
+    public?: BaseGroupSchema['public'];
+    expanded?: BaseGroupSchema['expanded'];
+    default?: BaseVersionSchema['default'];
+    color?: BaseDropdownSchema['color'];
+    href?: string;
+    openapi?: OpenApiConfig;
+    asyncapi?: AsyncApiConfig;
+};
+export type NodeActions = {
+    canHide: boolean;
+    canDuplicate: boolean;
+};
+export type NodeConfig = {
+    isExpandable: boolean;
+    showRoundedLineForParent: NavigationNodeType[];
+    actions: NodeActions;
+};
+export type PartialNodeConfig = {
+    isExpandable?: boolean;
+    showRoundedLineForParent?: NavigationNodeType[];
+    actions?: Partial<NodeActions>;
+};
+export type FlatNodeData = {
+    type: 'node';
+    node: NavigationNode;
+    depth: number;
+    parentType: NavigationNodeType | null;
+    lowerSiblingCounts: number[];
+    treeIndex: number;
+    parentTypes: (NavigationNodeType | null)[];
+    parentIds: (string | 0)[];
+    hasChildGroups: boolean;
+    hasVisibleChildren: boolean;
+    isLastSibling: boolean;
+};
+export type FlatNodeAddNew = {
+    type: 'add-new';
+    parentId: string;
+    depth: number;
+    lowerSiblingCounts: number[];
+    parentTypes: (NavigationNodeType | null)[];
+    parentIds: (string | 0)[];
+};
+export type FlatNodeRootAddNew = {
+    type: 'root-add-new';
+};
+export type FlatNode = FlatNodeData | FlatNodeAddNew | FlatNodeRootAddNew;

package/dist/editor-navigation/types.js

@@ -0,0 +1,11 @@
+export const DIVISION_TYPES = [
+    'tab',
+    'dropdown',
+    'anchor',
+    'language',
+    'product',
+    'version',
+    'item',
+];
+export const CONTENT_TYPES = ['page', 'group'];
+export const ROOT_NODE = 'root';

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

@@ -0,0 +1,5 @@
+import { NavigationNodeType, DivisionType, DivisionNode, ContentType, NavigationNode } from './types.js';
+export declare const isDivisionType: (type: NavigationNodeType) => type is DivisionType;
+export declare const isDivisionNode: (node: NavigationNode) => node is DivisionNode;
+export declare const isContentType: (type: NavigationNodeType) => type is ContentType;
+export declare const generateNodeId: (counter?: number) => string;

package/dist/editor-navigation/utils.js

@@ -0,0 +1,8 @@
+import { DIVISION_TYPES, CONTENT_TYPES, } from './types.js';
+export const isDivisionType = (type) => DIVISION_TYPES.some((t) => t === type);
+export const isDivisionNode = (node) => isDivisionType(node.type);
+export const isContentType = (type) => CONTENT_TYPES.some((t) => t === type);
+export const generateNodeId = (counter) => {
+    const counterPart = counter ? `-${counter}` : '';
+    return `nav-${Date.now()}${counterPart}-${Math.random().toString(36).substr(2, 9)}`;
+};

package/dist/index.d.ts

@@ -34,3 +34,4 @@ export * from './openapi/v2/types/index.js';
 export * from './openapi/v2/openApiToSchemaGraph.js';
 export * from './openapi/v2/schemaGraphToOpenApi.js';
 export * from './openapi/v2/isOpenAPIV3orV31Document.js';
+export * from './editor-navigation/index.js';

package/dist/index.js

@@ -72,3 +72,4 @@ export * from './openapi/v2/types/index.js';
 export * from './openapi/v2/openApiToSchemaGraph.js';
 export * from './openapi/v2/schemaGraphToOpenApi.js';
 export * from './openapi/v2/isOpenAPIV3orV31Document.js';
+export * from './editor-navigation/index.js';