@mintlify/validation 0.1.66 → 0.1.68

package/dist/index.js

@@ -1,12 +1,3 @@
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import { MintValidationResults } from './mint-config/common.js';
 import { flattenUnionErrorMessages } from './mint-config/flattenUnionErrorMessages.js';
@@ -15,29 +6,32 @@ import { validateAnchorsWarnings } from './mint-config/validateAnchorsWarnings.j
 import { validateVersionsInNavigation } from './mint-config/validateVersionsInNavigation.js';
 export function validateMintConfig(config) {
     var _a;
-    var results = new MintValidationResults();
+    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
-    var validateAnchorsWarningResult = validateAnchorsWarnings(config.anchors, config.navigation);
-    var validateVersionsInNavigationResult = validateVersionsInNavigation(config.navigation, (_a = config.versions) !== null && _a !== void 0 ? _a : []);
-    results.errors = __spreadArray(__spreadArray([], results.errors, true), validateVersionsInNavigationResult.errors, true);
-    results.warnings = __spreadArray(__spreadArray(__spreadArray([], results.warnings, true), validateVersionsInNavigationResult.warnings, true), validateAnchorsWarningResult.warnings, true);
+    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
-    var validateConfigResult = configSchema.safeParse(config);
+    const validateConfigResult = configSchema.safeParse(config);
     if (validateConfigResult.success == false) {
-        var errors = validateConfigResult.error.issues;
-        errors.forEach(function (e) {
+        const errors = validateConfigResult.error.issues;
+        errors.forEach((e) => {
             var _a;
-            var _b;
-            if (e.code === 'invalid_union' && ((_b = e.unionErrors) === null || _b === void 0 ? void 0 : _b.length) > 0) {
-                (_a = results.errors).push.apply(_a, flattenUnionErrorMessages(e.unionErrors));
+            if (e.code === 'invalid_union' && ((_a = e.unionErrors) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                results.errors.push(...flattenUnionErrorMessages(e.unionErrors));
             }
             else {
-                var message = e.message;
+                let message = e.message;
                 // Fallback if we forget to set a required_error
                 if (message === 'Required') {
                     message = 'Missing required field: ' + e.path.join('.');
@@ -52,9 +46,9 @@ export function validateMintConfig(config) {
 export * from './openapi/types/endpoint.js';
 export { convertOpenAPIV3_1ToEndpoint } from './openapi/convertOpenApi.js';
 export { convertSchema } from './openapi/convertSchema.js';
-export var mintConfigSchema = (function () {
+export const mintConfigSchema = (() => {
     var _a, _b, _c, _d, _e, _f;
-    var schema = zodToJsonSchema(configSchema, 'Schema');
+    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;

package/dist/mint-config/common.js

@@ -1,9 +1,7 @@
-var MintValidationResults = /** @class */ (function () {
-    function MintValidationResults() {
+export class MintValidationResults {
+    constructor() {
         this.status = 'success';
         this.errors = [];
         this.warnings = [];
     }
-    return MintValidationResults;
-}());
-export { MintValidationResults };
+}

package/dist/mint-config/flattenUnionErrorMessages.js

@@ -1,19 +1,10 @@
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 // TO DO: Write unit tests for this function.
 // TO DO: Prettify the output instead of just returning JSON objects.
 export function flattenUnionErrorMessages(unionErrors) {
-    return unionErrors.reduce(function (acc, unionError) {
+    return unionErrors.reduce((acc, unionError) => {
         if (Array.isArray(unionError.unionErrors) && unionError.unionErrors.length > 0) {
-            return __spreadArray(__spreadArray([], acc, true), flattenUnionErrorMessages(unionError.unionErrors), true);
+            return [...acc, ...flattenUnionErrorMessages(unionError.unionErrors)];
         }
-        return __spreadArray(__spreadArray([], acc, true), [unionError.message], false);
+        return [...acc, unionError.message];
     }, []);
 }

package/dist/mint-config/hexadecimalPattern.js

@@ -1 +1 @@
-export var hexadecimalPattern = /^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/;
+export const hexadecimalPattern = /^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/;

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-var amplitudeConfigInterfaceSchema = z.object({
+const amplitudeConfigInterfaceSchema = z.object({
     apiKey: z.string({
         required_error: 'Amplitude apiKey is missing.',
         invalid_type_error: 'Amplitude apiKey must be a string.',
@@ -7,7 +7,7 @@ var amplitudeConfigInterfaceSchema = z.object({
 }, {
     invalid_type_error: 'Amplitude analytics config must be an object with an apiKey property.',
 });
-var clearbitConfigInterfaceSchema = z.object({
+const clearbitConfigInterfaceSchema = z.object({
     publicApiKey: z.string({
         required_error: 'Clearbit publicApiKey is missing.',
         invalid_type_error: 'Clearbit publicApiKey must be a string.',
@@ -15,7 +15,7 @@ var clearbitConfigInterfaceSchema = z.object({
 }, {
     invalid_type_error: 'Clearbit config must be an object with a publicApiKey property.',
 });
-var fathomConfigInterfaceSchema = z.object({
+const fathomConfigInterfaceSchema = z.object({
     siteId: z.string({
         required_error: 'Fathom siteId is missing.',
         invalid_type_error: 'Fathom siteId must be a string.',
@@ -23,7 +23,7 @@ var fathomConfigInterfaceSchema = z.object({
 }, {
     invalid_type_error: 'Fathom analytics config must be an object with a siteId property.',
 });
-var googleAnalyticsConfigInterfaceSchema = z.object({
+const googleAnalyticsConfigInterfaceSchema = z.object({
     measurementId: z
         .string({
         required_error: 'Google Analytics measurementId is missing.',
@@ -33,7 +33,7 @@ var googleAnalyticsConfigInterfaceSchema = z.object({
 }, {
     invalid_type_error: 'Google Analytics config must be an object with a measurementId property.',
 });
-var googleTagManagerConfigInterfaceSchema = z.object({
+const googleTagManagerConfigInterfaceSchema = z.object({
     tagId: z
         .string({
         required_error: 'Google Tag Manager tagId is missing.',
@@ -43,7 +43,7 @@ var googleTagManagerConfigInterfaceSchema = z.object({
 }, {
     invalid_type_error: 'Google Tag Manager config must be an object with a tagId property.',
 });
-var hotjarConfigInterfaceSchema = z.object({
+const hotjarConfigInterfaceSchema = z.object({
     hjid: z.string({
         required_error: 'Hotjar hjid is missing.',
         invalid_type_error: 'Hotjar hjid must be a string.',
@@ -55,17 +55,17 @@ var hotjarConfigInterfaceSchema = z.object({
 }, {
     invalid_type_error: 'Hotjar config must be an object with a hjid and hjsv property.',
 });
-var koalaConfigInterfaceSchema = z.object({
+const koalaConfigInterfaceSchema = z.object({
     publicApiKey: z
         .string({
         required_error: 'Public Api Key is required for the Koala snippet to run.',
         invalid_type_error: 'Koala Public Api Key must be a string.',
     })
-        .refine(function (publicApiKey) { return publicApiKey.length >= 2; }, 'Koala Public Api Key must have at least two characters'),
+        .refine((publicApiKey) => publicApiKey.length >= 2, 'Koala Public Api Key must have at least two characters'),
 }, {
     invalid_type_error: 'Koala config must be an object with a publicApiKey property.',
 });
-var logrocketConfigInterfaceSchema = z.object({
+const logrocketConfigInterfaceSchema = z.object({
     appId: z.string({
         required_error: 'Logrocket appId is missing.',
         invalid_type_error: 'Logrocket appId must be a string.',
@@ -73,7 +73,7 @@ var logrocketConfigInterfaceSchema = z.object({
 }, {
     invalid_type_error: 'Logrocket config must be an object with an appId property.',
 });
-var mixpanelConfigInterfaceSchema = z.object({
+const mixpanelConfigInterfaceSchema = z.object({
     projectToken: z.string({
         required_error: 'Mixpanel projectToken is missing.',
         invalid_type_error: 'Mixpanel projectToken must be a string.',
@@ -81,13 +81,13 @@ var mixpanelConfigInterfaceSchema = z.object({
 }, {
     invalid_type_error: 'Mixpanel config must be an object with a projectToken property.',
 });
-var pirschConfigInterfaceSchema = z.object({
+const pirschConfigInterfaceSchema = z.object({
     id: z.string({
         required_error: 'Pirsch id is missing.',
         invalid_type_error: 'Pirsch id must be a string.',
     }),
 }, { invalid_type_error: 'Pirsch config must be an object with an id property.' });
-var postHogConfigInterfaceSchema = z.object({
+const postHogConfigInterfaceSchema = z.object({
     apiKey: z
         .string({
         required_error: 'Posthog apiKey is missing.',
@@ -101,17 +101,17 @@ var postHogConfigInterfaceSchema = z.object({
 }, {
     invalid_type_error: 'Posthog config must be an object with an apiKey property.',
 });
-var plausibleConfigInterfaceSchema = z.object({
+const plausibleConfigInterfaceSchema = z.object({
     domain: z
         .string({
         required_error: 'Plausible domain is missing.',
         invalid_type_error: 'Plausible domain must be a string.',
     })
-        .refine(function (domain) { return !domain.startsWith('http://') && !domain.startsWith('https://'); }, 'Plausible domain must not start with http:// or https://'),
+        .refine((domain) => !domain.startsWith('http://') && !domain.startsWith('https://'), 'Plausible domain must not start with http:// or https://'),
 }, {
     invalid_type_error: 'Plausible config must be an object with a domain property. The domain must not start with http:// or https://.',
 });
-export var analyticsSchema = z
+export const analyticsSchema = z
     .object({
     amplitude: amplitudeConfigInterfaceSchema.optional(),
     clearbit: clearbitConfigInterfaceSchema.optional(),

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { hexadecimalPattern } from '../hexadecimalPattern.js';
-export var gradientSchema = z.object({
+export const gradientSchema = z.object({
     from: z
         .string({
         invalid_type_error: 'Anchor color.from must be a string.',
@@ -18,7 +18,7 @@ export var gradientSchema = z.object({
     })
         .regex(hexadecimalPattern, 'Anchor color.to must be a hexadecimal color.'),
 });
-export var anchorColorSchema = z.union([
+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.'),

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

@@ -1,7 +1,7 @@
 import { iconTypes } from '@mintlify/models';
 import { z } from 'zod';
 import { anchorColorSchema } from './anchorColors.js';
-export var anchorSchema = z.object({
+export const anchorSchema = z.object({
     name: z
         .string({
         required_error: 'Every anchor must have a name.',
@@ -20,11 +20,11 @@ export var anchorSchema = z.object({
         .string({
         invalid_type_error: 'Anchor icon must be the name of a Font Awesome icon. Visit this link to see all the available icons: https://fontawesome.com/icons',
     })
-        .refine(function (iconStr) { return !iconStr.startsWith('fa-'); }, 'icon does not need to start with "fa-". Please delete "fa-" and keep the rest of the icon name.')
+        .refine((iconStr) => !iconStr.startsWith('fa-'), 'icon does not need to start with "fa-". Please delete "fa-" and keep the rest of the icon name.')
         .optional(),
     iconType: z
         .enum(iconTypes, {
-        errorMap: function () {
+        errorMap: () => {
             return {
                 message: 'anchor iconType must be one of the following strings: brands, duotone, light, sharp-solid, solid, thin',
             };
@@ -43,7 +43,7 @@ export var anchorSchema = z.object({
     })
         .optional(),
 });
-export var topAnchorSchema = z
+export const topAnchorSchema = z
     .object({
     name: z.string({
         required_error: 'topAnchor.name is missing, set it or delete the entire topAnchor property.',
@@ -56,7 +56,7 @@ export var topAnchorSchema = z
         .optional(),
     iconType: z
         .enum(iconTypes, {
-        errorMap: function () {
+        errorMap: () => {
             return {
                 message: 'topAnchor.iconType must be one of the following strings: brands, duotone, light, sharp-solid, solid, thin',
             };

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export var openApiSchema = z.union([
+export const openApiSchema = z.union([
     z.string({
         invalid_type_error: 'openapi must be a string or an array of strings of absolute or relative URLs pointing to your OpenAPI file.',
     }),
@@ -7,7 +7,7 @@ export var openApiSchema = z.union([
         invalid_type_error: 'openapi must be a string or an array of strings of absolute or relative URLs pointing to your OpenAPI file.',
     })),
 ]);
-export var apiSchema = z
+export const apiSchema = z
     .object({
     baseUrl: z
         .union([
@@ -19,7 +19,7 @@ export var apiSchema = z
         .object({
         method: z
             .enum(['bearer', 'basic', 'key', 'cobo'], {
-            errorMap: function () {
+            errorMap: () => {
                 return {
                     message: 'api.auth.method has to be one of: bearer, basic, or key',
                 };
@@ -35,7 +35,7 @@ export var apiSchema = z
         .object({
         mode: z
             .enum(['show', 'simple', 'hide'], {
-            errorMap: function () {
+            errorMap: () => {
                 return {
                     message: 'api.playground.mode must be one of the following strings: show, simple, or hide',
                 };

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-export var nameSchema = z
+export const nameSchema = z
     .string({ required_error: 'Name is missing.' })
     .min(1, 'Name cannot be empty.')
     .trim();
-export var logoSchema = z.union([
+export const logoSchema = z.union([
     z.string().min(3, 'Logo needs to be a path to your logo file including the file extension.'),
     z.object({
         light: z.string(),
@@ -13,10 +13,10 @@ export var logoSchema = z.union([
 ], {
     invalid_type_error: 'Logo must be a string or an object with light and dark properties.',
 });
-export var modeToggleSchema = z.object({
+export const modeToggleSchema = z.object({
     default: z
         .enum(['light', 'dark'], {
-        errorMap: function () {
+        errorMap: () => {
             return {
                 message: 'modeToggleSchema.default must be one of the following: light or dark',
             };
@@ -29,13 +29,13 @@ export var modeToggleSchema = z.object({
     })
         .optional(),
 });
-export var isWhiteLabeledSchema = z.boolean({
+export const isWhiteLabeledSchema = z.boolean({
     invalid_type_error: 'isWhiteLabeled must be a boolean. Try writing true or false without the quotes.',
 });
-export var metadataSchema = z.record(z.string({ invalid_type_error: 'metadata keys must be strings' }), z
+export const metadataSchema = z.record(z.string({ invalid_type_error: 'metadata keys must be strings' }), z
     .string({ invalid_type_error: 'metadata values must be strings' })
     .min(1, 'metadata values must not be empty'));
-export var footerSocialsSchema = z.union([
+export const footerSocialsSchema = z.union([
     // TO DO: deprecate array types
     z.array(z.object({
         type: z.string(),
@@ -45,7 +45,7 @@ export var footerSocialsSchema = z.union([
 ], {
     invalid_type_error: 'footerSocials must be an object where the key is the name of the social media and the value is the url to your profile. For example: { "twitter": "https://twitter.com/mintlify" }',
 });
-export var feedbackSchema = z.object({
+export const feedbackSchema = z.object({
     thumbsRating: z
         .boolean({
         invalid_type_error: 'thumbsRating must be a boolean. Try writing true or false without the quotes.',
@@ -62,61 +62,59 @@ export var feedbackSchema = z.object({
     })
         .optional(),
 });
-export var searchSchema = z.object({
+export const searchSchema = z.object({
     prompt: z
         .string({
         invalid_type_error: 'search.prompt must be a string. If this field is undefined, the default prompt is `Search...`',
     })
         .optional(),
 });
-var redirectSchema = z.object({
+const redirectSchema = z.object({
     source: z.string(),
     destination: z.string(),
 });
-export var redirectsSchema = z
+export const redirectsSchema = z
     .array(redirectSchema, {
     invalid_type_error: 'redirects must be an array of objects with source and destination properties',
 })
-    .refine(function (value) {
-    var keys = value.map(function (obj) { return obj.source; });
+    .refine((value) => {
+    const keys = value.map((obj) => obj.source);
     return new Set(keys).size === keys.length;
 }, {
     message: 'Sources in the array must be unique.',
 });
-export var createCtaButtonSchema = function (ctaButtonName) {
-    return z.union([
-        z
-            .object({
-            type: z.literal('link').optional(),
-            name: z.string({
-                required_error: 'Name must be defined when using a CTA button',
-                invalid_type_error: 'Name must be a string',
-            }),
-            url: z
-                .string({
-                required_error: ctaButtonName + '.url is missing',
-                invalid_type_error: ctaButtonName + '.url must be a string',
-            })
-                .min(1, ctaButtonName + '.url cannot be empty'),
+export const createCtaButtonSchema = (ctaButtonName) => z.union([
+    z
+        .object({
+        type: z.literal('link').optional(),
+        name: z.string({
+            required_error: 'Name must be defined when using a CTA button',
+            invalid_type_error: 'Name must be a string',
+        }),
+        url: z
+            .string({
+            required_error: ctaButtonName + '.url is missing',
+            invalid_type_error: ctaButtonName + '.url must be a string',
         })
-            .strict(ctaButtonName +
-            ' can only contain name, url, and type properties. Set a different type if you need to set other fields.'),
-        z
-            .object({
-            type: z.literal('github'),
-            url: z
-                .string({
-                required_error: ctaButtonName +
-                    '.url is missing. Please set the url to a link to your GitHub repository.',
-                invalid_type_error: ctaButtonName +
-                    '.url must be a string. Specifically, set the url to a link to your GitHub repository.',
-            })
-                .url(ctaButtonName + '.url must be a valid url pointing to your GitHub repository.'),
+            .min(1, ctaButtonName + '.url cannot be empty'),
+    })
+        .strict(ctaButtonName +
+        ' can only contain name, url, and type properties. Set a different type if you need to set other fields.'),
+    z
+        .object({
+        type: z.literal('github'),
+        url: z
+            .string({
+            required_error: ctaButtonName +
+                '.url is missing. Please set the url to a link to your GitHub repository.',
+            invalid_type_error: ctaButtonName +
+                '.url must be a string. Specifically, set the url to a link to your GitHub repository.',
         })
-            .strict(ctaButtonName +
-            ' can only contain url and type properties when type="github". Please delete any other properties you have set.'),
-    ], {
-        invalid_type_error: ctaButtonName +
-            ' must be an object. The object can have type="link" (the default) if you define a url and a name. You can also have type="github" if you define a url pointing to your GitHub repo and set the type in the object.',
-    });
-};
+            .url(ctaButtonName + '.url must be a valid url pointing to your GitHub repository.'),
+    })
+        .strict(ctaButtonName +
+        ' can only contain url and type properties when type="github". Please delete any other properties you have set.'),
+], {
+    invalid_type_error: ctaButtonName +
+        ' must be an object. The object can have type="link" (the default) if you define a url and a name. You can also have type="github" if you define a url pointing to your GitHub repo and set the type in the object.',
+});

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { hexadecimalPattern } from '../hexadecimalPattern.js';
 import { anchorColorSchema } from './anchorColors.js';
-export var colorsSchema = z
+export const colorsSchema = z
     .object({
     primary: z
         .string({ invalid_type_error: 'Primary color must be a string.' })

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

@@ -9,7 +9,7 @@ import { integrationsSchema } from './integrations.js';
 import { navigationSchema } from './navigation.js';
 import { tabsSchema, primaryTabSchema } from './tabs.js';
 import { versionsSchema } from './versions.js';
-export var configSchema = z.object({
+export const configSchema = z.object({
     $schema: z.string().url().optional().default('https://mintlify.com/schema.json'),
     mintlify: z.string().optional(),
     name: nameSchema,

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-export var faviconSchema = z
+export const faviconSchema = z
     .string({
     required_error: 'Favicon is missing. Please set favicon to the path of your favicon file. We recommend using a .svg or .png file. Mintlify automatically resizes your favicon to the sizes needed.',
     invalid_type_error: 'Favicon must be a string path pointing to the favicon file in your Mintlify folder.',
 })
-    .refine(function (val) { return val.split('.').pop() !== 'ico'; }, {
+    .refine((val) => val.split('.').pop() !== 'ico', {
     message: 'Favicon cannot be an .ico file.',
 });

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

@@ -1,11 +1,11 @@
 import { z } from 'zod';
-var intercomSchema = z
+const intercomSchema = z
     .string({ invalid_type_error: 'integrations.intercom must be a string' })
     .min(6, 'integrations.intercom must be a valid Intercom app ID');
-var frontchatSchema = z
+const frontchatSchema = z
     .string({ invalid_type_error: 'integrations.frontchat must be a string' })
     .min(6, 'integrations.frontchat must be a valid Front chat snippet id');
-export var integrationsSchema = z.object({
+export const integrationsSchema = z.object({
     intercom: intercomSchema.optional(),
     frontchat: frontchatSchema.optional(),
 }, { invalid_type_error: 'integrations must be an object' });

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

@@ -1,7 +1,7 @@
 import { iconTypes } from '@mintlify/models';
 import { z } from 'zod';
 // export to allow type testing against @mintlify/models
-export var baseNavigationGroupSchema = z
+export const baseNavigationGroupSchema = z
     .object({
     // We allow top-level groups to be an empty string if the user wants to hide the title.
     // Future work should refactor this so nested groups are non-empty strings.
@@ -12,7 +12,7 @@ export var baseNavigationGroupSchema = z
     icon: z.string({ invalid_type_error: 'Icon must be a string.' }).optional(),
     iconType: z
         .enum(iconTypes, {
-        errorMap: function () {
+        errorMap: () => {
             return {
                 message: 'group iconType must be one of the following strings: brands, duotone, light, sharp-solid, solid, thin',
             };
@@ -22,14 +22,12 @@ export var baseNavigationGroupSchema = z
     version: z.string({ invalid_type_error: 'Version must be a string.' }).optional(),
 }, { invalid_type_error: 'Navigation entry must be an object.' })
     .strict('Navigation entry can only contain group, pages, icon, and version.');
-var navigationGroupSchema = baseNavigationGroupSchema.extend({
-    pages: z.lazy(function () {
-        return z
-            .array(z.union([navigationGroupSchema, z.string().min(1, 'Page cannot be an empty string.')]))
-            .min(1, "Pages array can't be empty.");
-    }),
+const navigationGroupSchema = baseNavigationGroupSchema.extend({
+    pages: z.lazy(() => z
+        .array(z.union([navigationGroupSchema, z.string().min(1, 'Page cannot be an empty string.')]))
+        .min(1, "Pages array can't be empty.")),
 });
-export var navigationSchema = z
+export const navigationSchema = z
     .array(navigationGroupSchema, {
     required_error: 'Navigation is missing.',
     invalid_type_error: 'Navigation must be an array.',

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-var tabSchema = z.object({
+const tabSchema = z.object({
     name: z
         .string({
         required_error: 'Every tab must have a name.',
@@ -15,8 +15,8 @@ var tabSchema = z.object({
         .trim()
         .min(1, 'Tab URL is missing.'),
 });
-export var tabsSchema = tabSchema.array();
-export var primaryTabSchema = z
+export const tabsSchema = tabSchema.array();
+export const primaryTabSchema = z
     .object({
     name: z.string({
         required_error: 'primaryTab.name is missing, set it or delete the entire primaryTab property.',

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-var versionSchema = z.union([
+const versionSchema = z.union([
     z.string({ invalid_type_error: 'Versions must be an array of strings.' }),
     z
         .object({
@@ -8,6 +8,6 @@ var versionSchema = z.union([
     })
         .strict('Object must contain name and url properties'),
 ]);
-export var versionsSchema = z
+export const versionsSchema = z
     .array(versionSchema)
     .min(1, 'Versions array cannot be empty. Either delete the property or add strings to the array.');

package/dist/mint-config/validateAnchorsWarnings.js

@@ -1,16 +1,16 @@
 import { MintValidationResults } from './common.js';
 import { navigationSchema } from './schemas/navigation.js';
 export function validateAnchorsWarnings(anchors, navigation) {
-    var results = new MintValidationResults();
+    const results = new MintValidationResults();
     if (anchors &&
         Array.isArray(anchors) &&
         navigation &&
         navigationSchema.safeParse(navigation).success) {
-        anchors.forEach(function (anchor) {
+        anchors.forEach((anchor) => {
             if (!anchor.url.startsWith('mailto:') &&
                 !anchor.url.startsWith('http') &&
                 !anchor.url.startsWith('https') &&
-                !navigation.some(function (nav) { return pageStartsWith(nav, anchor.url); })) {
+                !navigation.some((nav) => pageStartsWith(nav, anchor.url))) {
                 results.warnings.push('No pages in the navigation match anchor ' +
                     anchor.url +
                     ' you should have at least one page that starts with ' +
@@ -28,7 +28,7 @@ function pageStartsWith(navEntry, prefix) {
         return false;
     }
     else {
-        return navEntry.pages.some(function (entry) {
+        return navEntry.pages.some((entry) => {
             return pageStartsWith(entry, prefix);
         });
     }