@mintlify/validation 0.1.120 → 0.1.122

package/dist/index.d.ts

@@ -1,12 +1,337 @@
-import type { ConfigType } from '@mintlify/models';
-import { MintValidationResults } from './mint-config/common.js';
-export declare function validateMintConfig(config: ConfigType): MintValidationResults;
+export declare function validateMintConfig(value: unknown): import("zod").SafeParseError<{
+    navigation: import("@mintlify/models").NavigationGroup[];
+    name: string;
+    favicon: string;
+    colors: {
+        primary: string;
+        light?: string | undefined;
+        dark?: string | undefined;
+        background?: {
+            light?: string | undefined;
+            dark?: string | undefined;
+        } | undefined;
+        anchors?: string | {
+            from: string;
+            to: string;
+            via?: string | undefined;
+        } | undefined;
+        ultraLight?: any;
+        ultraDark?: any;
+    };
+    $schema?: string | undefined;
+    mintlify?: string | undefined;
+    logo?: string | {
+        light: string;
+        dark: string;
+        href?: string | undefined;
+    } | undefined;
+    openapi?: string | string[] | undefined;
+    api?: {
+        baseUrl?: string | string[] | undefined;
+        auth?: {
+            method?: "bearer" | "basic" | "key" | "cobo" | undefined;
+            name?: string | undefined;
+            inputPrefix?: string | undefined;
+        } | undefined;
+        playground?: {
+            mode?: "show" | "simple" | "hide" | undefined;
+        } | undefined;
+        request?: {
+            example?: {
+                showOptionalParams?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        maintainOrder?: boolean | undefined;
+    } | undefined;
+    modeToggle?: {
+        default?: "light" | "dark" | undefined;
+        isHidden?: boolean | undefined;
+    } | undefined;
+    versions?: (string | {
+        name: string;
+        url: string;
+    })[] | undefined;
+    metadata?: Record<string, string> | undefined;
+    topbarCtaButton?: {
+        name: string;
+        url: string;
+        type?: "link" | undefined;
+    } | {
+        type: "github";
+        url: string;
+    } | undefined;
+    topbarLinks?: ({
+        name: string;
+        url: string;
+        type?: "link" | undefined;
+    } | {
+        type: "github";
+        url: string;
+    })[] | undefined;
+    primaryTab?: {
+        name: string;
+    } | undefined;
+    topAnchor?: {
+        name: string;
+        icon?: string | undefined;
+        iconType?: "light" | "brands" | "duotone" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
+    } | undefined;
+    anchors?: {
+        name: string;
+        url: string;
+        icon?: string | undefined;
+        iconType?: "light" | "brands" | "duotone" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
+        color?: string | {
+            from: string;
+            to: string;
+            via?: string | undefined;
+        } | undefined;
+        isDefaultHidden?: boolean | undefined;
+        version?: string | undefined;
+    }[] | undefined;
+    tabs?: {
+        name: string;
+        url: string;
+        version?: string | undefined;
+    }[] | undefined;
+    footerSocials?: {
+        type: string;
+        url: string;
+    }[] | Record<string, string> | undefined;
+    backgroundImage?: string | undefined;
+    feedback?: {
+        thumbsRating?: boolean | undefined;
+        suggestEdit?: boolean | undefined;
+        raiseIssue?: boolean | undefined;
+    } | undefined;
+    analytics?: {
+        amplitude?: {
+            apiKey: string;
+        } | undefined;
+        clearbit?: {
+            publicApiKey: string;
+        } | undefined;
+        fathom?: {
+            siteId: string;
+        } | undefined;
+        ga4?: {
+            measurementId: string;
+        } | undefined;
+        gtm?: {
+            tagId: string;
+        } | undefined;
+        hotjar?: {
+            hjid: string;
+            hjsv: string;
+        } | undefined;
+        koala?: {
+            publicApiKey: string;
+        } | undefined;
+        logrocket?: {
+            appId: string;
+        } | undefined;
+        mixpanel?: {
+            projectToken: string;
+        } | undefined;
+        pirsch?: {
+            id: string;
+        } | undefined;
+        posthog?: {
+            apiKey: string;
+            apiHost?: string | undefined;
+        } | undefined;
+        plausible?: {
+            domain: string;
+        } | undefined;
+    } | undefined;
+    integrations?: {
+        intercom?: string | undefined;
+        frontchat?: string | undefined;
+    } | undefined;
+    isWhiteLabeled?: boolean | undefined;
+    search?: {
+        prompt?: string | undefined;
+    } | undefined;
+    redirects?: {
+        source: string;
+        destination: string;
+    }[] | undefined;
+    seo?: {
+        indexHiddenPages?: boolean | undefined;
+    } | undefined;
+}> | {
+    warnings: import("zod").ZodIssue[];
+    success: true;
+    data: {
+        navigation: import("@mintlify/models").NavigationGroup[];
+        name: string;
+        $schema: string;
+        favicon: string;
+        colors: {
+            primary: string;
+            light?: string | undefined;
+            dark?: string | undefined;
+            background?: {
+                light?: string | undefined;
+                dark?: string | undefined;
+            } | undefined;
+            anchors?: string | {
+                from: string;
+                to: string;
+                via?: string | undefined;
+            } | undefined;
+            ultraLight?: any;
+            ultraDark?: any;
+        };
+        mintlify?: string | undefined;
+        logo?: string | {
+            light: string;
+            dark: string;
+            href?: string | undefined;
+        } | undefined;
+        openapi?: string | string[] | undefined;
+        api?: {
+            baseUrl?: string | string[] | undefined;
+            auth?: {
+                method?: "bearer" | "basic" | "key" | "cobo" | undefined;
+                name?: string | undefined;
+                inputPrefix?: string | undefined;
+            } | undefined;
+            playground?: {
+                mode: "show" | "simple" | "hide";
+            } | undefined;
+            request?: {
+                example?: {
+                    showOptionalParams: boolean;
+                } | undefined;
+            } | undefined;
+            maintainOrder?: boolean | undefined;
+        } | undefined;
+        modeToggle?: {
+            default?: "light" | "dark" | undefined;
+            isHidden?: boolean | undefined;
+        } | undefined;
+        versions?: (string | {
+            name: string;
+            url: string;
+        })[] | undefined;
+        metadata?: Record<string, string> | undefined;
+        topbarCtaButton?: {
+            name: string;
+            url: string;
+            type?: "link" | undefined;
+        } | {
+            type: "github";
+            url: string;
+        } | undefined;
+        topbarLinks?: ({
+            name: string;
+            url: string;
+            type?: "link" | undefined;
+        } | {
+            type: "github";
+            url: string;
+        })[] | undefined;
+        primaryTab?: {
+            name: string;
+        } | undefined;
+        topAnchor?: {
+            name: string;
+            icon?: string | undefined;
+            iconType?: "light" | "brands" | "duotone" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
+        } | undefined;
+        anchors?: {
+            name: string;
+            url: string;
+            icon?: string | undefined;
+            iconType?: "light" | "brands" | "duotone" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
+            color?: string | {
+                from: string;
+                to: string;
+                via?: string | undefined;
+            } | undefined;
+            isDefaultHidden?: boolean | undefined;
+            version?: string | undefined;
+        }[] | undefined;
+        tabs?: {
+            name: string;
+            url: string;
+            version?: string | undefined;
+        }[] | undefined;
+        footerSocials?: {
+            type: string;
+            url: string;
+        }[] | Record<string, string> | undefined;
+        backgroundImage?: string | undefined;
+        feedback?: {
+            thumbsRating?: boolean | undefined;
+            suggestEdit?: boolean | undefined;
+            raiseIssue?: boolean | undefined;
+        } | undefined;
+        analytics?: {
+            amplitude?: {
+                apiKey: string;
+            } | undefined;
+            clearbit?: {
+                publicApiKey: string;
+            } | undefined;
+            fathom?: {
+                siteId: string;
+            } | undefined;
+            ga4?: {
+                measurementId: string;
+            } | undefined;
+            gtm?: {
+                tagId: string;
+            } | undefined;
+            hotjar?: {
+                hjid: string;
+                hjsv: string;
+            } | undefined;
+            koala?: {
+                publicApiKey: string;
+            } | undefined;
+            logrocket?: {
+                appId: string;
+            } | undefined;
+            mixpanel?: {
+                projectToken: string;
+            } | undefined;
+            pirsch?: {
+                id: string;
+            } | undefined;
+            posthog?: {
+                apiKey: string;
+                apiHost?: string | undefined;
+            } | undefined;
+            plausible?: {
+                domain: string;
+            } | undefined;
+        } | undefined;
+        integrations?: {
+            intercom?: string | undefined;
+            frontchat?: string | undefined;
+        } | undefined;
+        isWhiteLabeled?: boolean | undefined;
+        search?: {
+            prompt?: string | undefined;
+        } | undefined;
+        redirects?: {
+            source: string;
+            destination: string;
+        }[] | undefined;
+        seo?: {
+            indexHiddenPages?: boolean | undefined;
+        } | undefined;
+    };
+};
 export * from './openapi/types/endpoint.js';
 export { OpenApiToEndpointConverter } from './openapi/OpenApiToEndpointConverter.js';
 export { SchemaConverter } from './openapi/SchemaConverter.js';
 export { generateExampleFromSchema } from './openapi/generateExampleFromSchema.js';
-export declare const mintConfigSchema: any;
-export { sort } from './sort.js';
-export { Sortable } from './sortable/Sortable.js';
-export { any } from './any.js';
-export { isSortable } from './sortable/isSortable.js';
+export declare const mintConfigJsonSchema: import("zod-to-json-schema/src/parseDef.js").JsonSchema7Type & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: import("zod-to-json-schema/src/parseDef.js").JsonSchema7Type;
+    } | undefined;
+};

package/dist/index.js

@@ -1,61 +1,25 @@
 import { zodToJsonSchema } from 'zod-to-json-schema';
-import { MintValidationResults } from './mint-config/common.js';
-import { flattenUnionErrorMessages } from './mint-config/flattenUnionErrorMessages.js';
-import { configSchema } from './mint-config/schemas/config.js';
-import { validateAnchorsWarnings } from './mint-config/validateAnchorsWarnings.js';
-import { validateVersionsInNavigation } from './mint-config/validateVersionsInNavigation.js';
-export function validateMintConfig(config) {
-    var _a;
-    const results = new MintValidationResults();
-    if (config == null || config == undefined || Object.entries(config).length === 0) {
-        results.errors.push('Mint Config object cannot be empty.');
-        results.status = 'error';
-        return results;
-    }
-    // Specific warnings and errors
-    const validateAnchorsWarningResult = validateAnchorsWarnings(config.anchors, config.navigation);
-    const validateVersionsInNavigationResult = validateVersionsInNavigation(config.navigation, (_a = config.versions) !== null && _a !== void 0 ? _a : []);
-    results.errors = [...results.errors, ...validateVersionsInNavigationResult.errors];
-    results.warnings = [
-        ...results.warnings,
-        ...validateVersionsInNavigationResult.warnings,
-        ...validateAnchorsWarningResult.warnings,
-    ];
-    // Global check
-    const validateConfigResult = configSchema.safeParse(config);
-    if (validateConfigResult.success == false) {
-        const errors = validateConfigResult.error.issues;
-        errors.forEach((e) => {
-            var _a;
-            if (e.code === 'invalid_union' && ((_a = e.unionErrors) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-                results.errors.push(...flattenUnionErrorMessages(e.unionErrors));
-            }
-            else {
-                let message = e.message;
-                // Fallback if we forget to set a required_error
-                if (message === 'Required') {
-                    message = 'Missing required field: ' + e.path.join('.');
-                }
-                results.errors.push(message);
-            }
-        });
-    }
-    results.status = results.errors.length ? 'error' : 'success';
-    return results;
+import { refineMissingVersions } from './mint-config/refinements/refineMissingVersions.js';
+import { colorsSchema } from './mint-config/schemas/colors.js';
+import { mintConfigSchema } from './mint-config/schemas/config.js';
+import { aggregateWarnings } from './mint-config/warnings/aggregateWarnings.js';
+export function validateMintConfig(value) {
+    const refinedSchema = mintConfigSchema.superRefine(refineMissingVersions);
+    const validationResults = refinedSchema.safeParse(value);
+    if (!validationResults.success)
+        return validationResults;
+    return Object.assign(Object.assign({}, validationResults), { warnings: aggregateWarnings(validationResults.data) });
 }
 export * from './openapi/types/endpoint.js';
 export { OpenApiToEndpointConverter } from './openapi/OpenApiToEndpointConverter.js';
 export { SchemaConverter } from './openapi/SchemaConverter.js';
 export { generateExampleFromSchema } from './openapi/generateExampleFromSchema.js';
-export const mintConfigSchema = (() => {
-    var _a, _b, _c, _d, _e, _f;
-    const schema = zodToJsonSchema(configSchema, 'Schema');
-    (_b = (_a = schema.definitions) === null || _a === void 0 ? void 0 : _a.Schema) === null || _b === void 0 ? true : delete _b.properties.__injected;
-    (_d = (_c = schema.definitions) === null || _c === void 0 ? void 0 : _c.Schema) === null || _d === void 0 ? true : delete _d.properties.colors.properties.ultraDark;
-    (_f = (_e = schema.definitions) === null || _e === void 0 ? void 0 : _e.Schema) === null || _f === void 0 ? true : delete _f.properties.colors.properties.ultraLight;
-    return schema;
+export const mintConfigJsonSchema = (() => {
+    const cleanedSchema = mintConfigSchema.extend({
+        colors: colorsSchema.omit({
+            ultraDark: true,
+            ultraLight: true,
+        }),
+    });
+    return zodToJsonSchema(cleanedSchema, 'Schema');
 })();
-export { sort } from './sort.js';
-export { Sortable } from './sortable/Sortable.js';
-export { any } from './any.js';
-export { isSortable } from './sortable/isSortable.js';

package/dist/mint-config/flattenNavigationVersions.d.ts

@@ -0,0 +1,2 @@
+import { NavigationEntry } from '@mintlify/models';
+export declare function flattenNavigationVersions(nav: NavigationEntry[]): string[];

package/dist/mint-config/flattenNavigationVersions.js

@@ -0,0 +1,10 @@
+export function flattenNavigationVersions(nav) {
+    return nav.flatMap((val) => {
+        if (typeof val === 'string')
+            return [];
+        const versions = flattenNavigationVersions(val.pages);
+        if (val.version !== undefined)
+            versions.push(val.version);
+        return versions;
+    });
+}

package/dist/mint-config/refinements/refineMissingVersions.d.ts

@@ -0,0 +1,6 @@
+import { VersionType, Navigation } from '@mintlify/models';
+import { RefinementCtx } from 'zod';
+export declare function refineMissingVersions({ navigation, versions, }: {
+    navigation: Navigation;
+    versions?: VersionType[];
+}, ctx: RefinementCtx): void;

package/dist/mint-config/refinements/refineMissingVersions.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { flattenNavigationVersions } from '../flattenNavigationVersions.js';
+export function refineMissingVersions({ navigation, versions = [], }, ctx) {
+    const versionsFromNavigation = flattenNavigationVersions(navigation);
+    versionsFromNavigation.forEach((v) => {
+        if (!versions.includes(v)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Version ${v} is not included in the versions array, but is used in the navigation. Please add ${v} to the versions array.`,
+            });
+        }
+    });
+}

package/dist/mint-config/schemas/anchorColors.js

@@ -1,27 +1,12 @@
 import { z } from 'zod';
-import { hexadecimalPattern } from '../hexadecimalPattern.js';
+import { hexColor } from './hexColor.js';
 export const gradientSchema = z.object({
-    from: z
-        .string({
-        invalid_type_error: 'Anchor color.from must be a string.',
-    })
-        .regex(hexadecimalPattern, 'Anchor color.from must be a hexadecimal color.'),
-    via: z
-        .string({
-        invalid_type_error: 'Anchor color.via must be a string.',
-    })
-        .regex(hexadecimalPattern, 'Anchor color.via must be undefined or a hexadecimal color.')
-        .optional(),
-    to: z
-        .string({
-        invalid_type_error: 'Anchor color.to must be a string.',
-    })
-        .regex(hexadecimalPattern, 'Anchor color.to must be a hexadecimal color.'),
+    from: hexColor('Anchor color.from'),
+    via: hexColor('Anchor color.via').optional(),
+    to: hexColor('Anchor color.to'),
 });
 export const anchorColorSchema = z.union([
-    z
-        .string({ invalid_type_error: 'Anchor color must be a string.' })
-        .regex(hexadecimalPattern, 'Anchor color must be a hexadecimal color.'),
+    hexColor('Anchor color'),
     gradientSchema.strict('Anchors with gradient colors can only have properties from, via, and to with valid hexadecimal colors.'),
 ], {
     invalid_type_error: 'Anchor color must be a string or an object with from and to properties.',

package/dist/mint-config/schemas/anchors.d.ts

@@ -23,7 +23,7 @@ export declare const anchorSchema: z.ZodObject<{
     name: string;
     url: string;
     icon?: string | undefined;
-    iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
+    iconType?: "light" | "brands" | "duotone" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
     color?: string | {
         from: string;
         to: string;
@@ -35,7 +35,7 @@ export declare const anchorSchema: z.ZodObject<{
     name: string;
     url: string;
     icon?: string | undefined;
-    iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
+    iconType?: "light" | "brands" | "duotone" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
     color?: string | {
         from: string;
         to: string;
@@ -51,9 +51,9 @@ export declare const topAnchorSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     name: string;
     icon?: string | undefined;
-    iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
+    iconType?: "light" | "brands" | "duotone" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
 }, {
     name: string;
     icon?: string | undefined;
-    iconType?: "brands" | "duotone" | "light" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
+    iconType?: "light" | "brands" | "duotone" | "regular" | "sharp-solid" | "solid" | "thin" | undefined;
 }>;

package/dist/mint-config/schemas/colors.js

@@ -1,34 +1,15 @@
 import { z } from 'zod';
-import { hexadecimalPattern } from '../hexadecimalPattern.js';
 import { anchorColorSchema } from './anchorColors.js';
+import { hexColor } from './hexColor.js';
 export const colorsSchema = z
     .object({
-    primary: z
-        .string({ invalid_type_error: 'Primary color must be a string.' })
-        .min(1, 'Color primary is missing.')
-        .regex(hexadecimalPattern, 'Primary color must be a hexadecimal color including the # at the start.'),
-    light: z
-        .string({ invalid_type_error: 'Light color must be a string.' })
-        .regex(hexadecimalPattern, 'Light color must be a hexadecimal color including the # at the start.')
-        .optional(),
-    dark: z
-        .string({ invalid_type_error: 'Dark color must be a string.' })
-        .regex(hexadecimalPattern, 'Dark color must be a hexadecimal color including the # at the start.')
-        .optional(),
+    primary: hexColor('Primary color'),
+    light: hexColor('Light color').optional(),
+    dark: hexColor('Dark color').optional(),
     background: z
         .object({
-        light: z
-            .string({
-            invalid_type_error: 'Background light color must be a string.',
-        })
-            .regex(hexadecimalPattern, 'Background light color must be a hexadecimal color including the # at the start.')
-            .optional(),
-        dark: z
-            .string({
-            invalid_type_error: 'Background dark color must be a string.',
-        })
-            .regex(hexadecimalPattern, 'Background dark color must be a hexadecimal color including the # at the start.')
-            .optional(),
+        light: hexColor('Background light color').optional(),
+        dark: hexColor('Background dark color').optional(),
     })
         .optional(),
     anchors: anchorColorSchema.optional(),