@mintlify/prebuild 1.0.798 → 1.0.800

package/dist/createPage/index.d.ts

@@ -1,6 +1,6 @@
 import { AsyncAPIFile } from '@mintlify/common';
 import { OpenApiFile, DecoratedNavigationPage } from '@mintlify/models';
-export declare const createPage: (pagePath: string, pageContent: string, contentDirectoryPath: string, openApiFiles: OpenApiFile[], asyncApiFiles: AsyncAPIFile[], suppressErrLog?: boolean) => Promise<{
+export declare const createPage: (pagePath: string, pageContent: string, contentDirectoryPath: string, openApiFiles: OpenApiFile[], asyncApiFiles: AsyncAPIFile[], onError?: (message: string) => void) => Promise<{
     pageMetadata: DecoratedNavigationPage;
     pageContent: string;
     slug: string;

package/dist/createPage/index.js

@@ -1,17 +1,23 @@
 import { getDecoratedNavPageAndSlug } from '@mintlify/common';
 import { getLocationErrString } from '../errorMessages/getLocationErrString.js';
 import { preparseMdx } from './preparseMdx/index.js';
-export const createPage = async (pagePath, pageContent, contentDirectoryPath, openApiFiles, asyncApiFiles, suppressErrLog = false) => {
+export const createPage = async (pagePath, pageContent, contentDirectoryPath, openApiFiles, asyncApiFiles, onError) => {
     let pageMetadata;
     let slug;
     try {
         const { pageMetadata: metadata, slug: pageSlug } = getDecoratedNavPageAndSlug(pagePath, pageContent, openApiFiles, asyncApiFiles);
         pageMetadata = metadata;
         slug = pageSlug;
-        pageContent = await preparseMdx(pageContent, contentDirectoryPath, pagePath, suppressErrLog);
+        pageContent = await preparseMdx(pageContent, contentDirectoryPath, pagePath, onError);
     }
     catch (err) {
-        console.log(`\n ⚠️  Parsing error in the frontmatter: ${getLocationErrString(pagePath, contentDirectoryPath, err)}: `);
+        const message = `\n ⚠️  Parsing error in the frontmatter: ${getLocationErrString(pagePath, contentDirectoryPath, err)}: `;
+        if (onError) {
+            onError(message);
+        }
+        else {
+            console.log(message);
+        }
         // TODO - pages completely break in our backend when frontmatter is broken.
         // Unify "createPage" function across applications and properly catch errors
         throw err;

package/dist/createPage/preparseMdx/index.d.ts

@@ -1,2 +1,4 @@
-export declare const preparseMdx: (fileContent: string, contentDirectoryPath: string, filePath: string, suppressErrLog?: boolean) => Promise<string>;
-export declare const preparseMdxTree: (fileContent: string, contentDirectoryPath: string, filePath: string, suppressErrLog?: boolean) => Promise<import("mdast").Root>;
+import { formatError } from '../../errorMessages/formatError.js';
+export { formatError };
+export declare const preparseMdx: (fileContent: string, contentDirectoryPath: string, filePath: string, onError?: (message: string) => void) => Promise<string>;
+export declare const preparseMdxTree: (fileContent: string, contentDirectoryPath: string, filePath: string, onError?: (message: string) => void) => Promise<import("mdast").Root>;

package/dist/createPage/preparseMdx/index.js

@@ -1,23 +1,32 @@
 import { coreRemark, getAST } from '@mintlify/common';
 import { formatError } from '../../errorMessages/formatError.js';
-export const preparseMdx = async (fileContent, contentDirectoryPath, filePath, suppressErrLog = false) => {
+export { formatError };
+export const preparseMdx = async (fileContent, contentDirectoryPath, filePath, onError) => {
     try {
         return String(await coreRemark().process(fileContent));
     }
     catch (error) {
-        if (!suppressErrLog) {
-            console.log(formatError(error, filePath, contentDirectoryPath));
+        const message = formatError(error, filePath, contentDirectoryPath);
+        if (onError) {
+            onError(message);
+        }
+        else {
+            console.log(message);
         }
         return `🚧 A parsing error occured. Please contact the owner of this website.`;
     }
 };
-export const preparseMdxTree = async (fileContent, contentDirectoryPath, filePath, suppressErrLog = false) => {
+export const preparseMdxTree = async (fileContent, contentDirectoryPath, filePath, onError) => {
     try {
         return getAST(fileContent, filePath);
     }
     catch (error) {
-        if (!suppressErrLog) {
-            console.error(formatError(error, filePath, contentDirectoryPath));
+        const message = formatError(error, filePath, contentDirectoryPath);
+        if (onError) {
+            onError(message);
+        }
+        else {
+            console.error(message);
         }
         return getAST(`🚧 A parsing error occured. Please contact the owner of this website.`);
     }

package/dist/prebuild/update/ConfigUpdater.d.ts

@@ -3,8 +3,8 @@ export declare class ConfigUpdater<T> {
     private type;
     constructor(type: ConfigType);
     getConfigType(): "mint" | "docs";
-    getConfig(configPath: string): Promise<T>;
-    validateConfigJsonString: (configContents: string) => Promise<{
+    getConfig(configPath: string, onError?: (message: string) => void): Promise<T>;
+    validateConfigJsonString: (configContents: string, onError?: (message: string) => void) => Promise<{
         data: T;
         warnings: import("zod").ZodIssue[];
         success: true;

package/dist/prebuild/update/ConfigUpdater.js

@@ -6,18 +6,32 @@ import { join } from 'path';
 const { readFile } = _promises;
 export class ConfigUpdater {
     constructor(type) {
-        this.validateConfigJsonString = async (configContents) => {
-            const configObj = this.parseConfigJson(configContents);
+        this.validateConfigJsonString = async (configContents, onError) => {
+            const configObj = this.parseConfigJson(configContents, onError);
             const validationResults = this.type === 'mint' ? validateMintConfig(configObj) : validateDocsConfig(configObj);
             if (!validationResults.success) {
-                console.error(Chalk.red(`🚨 Invalid ${this.type}.json:`));
-                validationResults.error.issues.forEach((issue) => console.error(Chalk.red(formatIssue(issue))));
+                const errorMsg = `🚨 Invalid ${this.type}.json:`;
+                const issues = validationResults.error.issues.map((issue) => formatIssue(issue));
+                if (onError) {
+                    onError(errorMsg);
+                    issues.forEach((issue) => onError(issue));
+                }
+                else {
+                    console.error(Chalk.red(errorMsg));
+                    issues.forEach((issue) => console.error(Chalk.red(issue)));
+                }
                 throw Error();
             }
-            if (validationResults.warnings.length > 0) {
-                if (validationResults.warnings.length > 0) {
-                    console.warn(Chalk.yellow(`⚠️ Warnings found in ${this.type}.json:`));
-                    validationResults.warnings.forEach((issue) => console.warn(Chalk.yellow(formatIssue(issue))));
+            if ('warnings' in validationResults && validationResults.warnings.length > 0) {
+                const warnMsg = `⚠️ Warnings found in ${this.type}.json:`;
+                const warnings = validationResults.warnings.map((issue) => formatIssue(issue));
+                if (onError) {
+                    onError(warnMsg);
+                    warnings.forEach((warning) => onError(warning));
+                }
+                else {
+                    console.warn(Chalk.yellow(warnMsg));
+                    warnings.forEach((warning) => console.warn(Chalk.yellow(warning)));
                 }
             }
             return { ...validationResults, data: validationResults.data };
@@ -42,7 +56,7 @@ export class ConfigUpdater {
                 throw Error(`Unable to write ${this.type}.json: ${err}`);
             }
         };
-        this.parseConfigJson = (configContents) => {
+        this.parseConfigJson = (configContents, onError) => {
             let configObj;
             try {
                 configObj = JSON.parse(configContents);
@@ -50,10 +64,22 @@ export class ConfigUpdater {
             catch (e) {
                 if (typeof e === 'object' && e != null) {
                     if ('name' in e && e.name === 'SyntaxError') {
-                        console.error(`🚨 ${Chalk.red(`${this.type}.json has invalid JSON. You are likely missing a comma or a bracket. You can paste your ${this.type}.json file into https://jsonlint.com/ to get a more specific error message.`)}`);
+                        const msg = `🚨 ${this.type}.json has invalid JSON. You are likely missing a comma or a bracket. You can paste your ${this.type}.json file into https://jsonlint.com/ to get a more specific error message.`;
+                        if (onError) {
+                            onError(msg);
+                        }
+                        else {
+                            console.error(Chalk.red(msg));
+                        }
                     }
                     else if ('message' in e) {
-                        console.error(`🚨 ${Chalk.red(e.message)}`);
+                        const msg = `🚨 ${e.message}`;
+                        if (onError) {
+                            onError(msg);
+                        }
+                        else {
+                            console.error(Chalk.red(msg));
+                        }
                     }
                 }
                 throw Error();
@@ -65,9 +91,9 @@ export class ConfigUpdater {
     getConfigType() {
         return this.type;
     }
-    async getConfig(configPath) {
+    async getConfig(configPath, onError) {
         const configContents = await this.readConfigFile(configPath);
-        const validationResults = await this.validateConfigJsonString(configContents);
+        const validationResults = await this.validateConfigJsonString(configContents, onError);
         return validationResults.data;
     }
 }

package/dist/prebuild/update/docsConfig/generateOpenApiFromDocsConfig.js

@@ -82,31 +82,41 @@ export const generateOpenApiFromDocsConfig = async (navigation, openApiFiles, pa
         if ('openapi' in nav && nav.openapi !== null) {
             const openapiProp = nav.openapi;
             if (typeof openapiProp === 'string') {
-                return openapiProp;
+                return { source: openapiProp, directory: undefined };
             }
             else if (Array.isArray(openapiProp) && openapiProp.length > 0) {
-                return openapiProp[0];
+                return { source: openapiProp[0], directory: undefined };
             }
             else if (typeof openapiProp === 'object' &&
                 'source' in openapiProp &&
                 typeof openapiProp.source === 'string') {
-                return openapiProp.source;
+                const directory = 'directory' in openapiProp && typeof openapiProp.directory === 'string'
+                    ? openapiProp.directory
+                    : undefined;
+                return {
+                    source: openapiProp.source,
+                    directory,
+                };
             }
         }
-        return undefined;
+        return { source: undefined, directory: undefined };
     }
     const skipBulkForNode = new Set();
     const skipBulkForNodeId = new Set();
     let numNodes = 0;
-    async function processNav(nav, inheritedOpenApi, openApiOwner) {
+    async function processNav(nav, inheritedOpenApi, inheritedDirectory, openApiOwner) {
         const nodeId = numNodes++;
-        const currentOpenApi = extractOpenApiFromNav(nav) ?? inheritedOpenApi;
-        const currentOpenApiOwner = extractOpenApiFromNav(nav) ? nodeId : openApiOwner;
+        const extracted = extractOpenApiFromNav(nav);
+        const currentOpenApi = extracted.source ?? inheritedOpenApi;
+        const currentDirectory = extracted.source
+            ? extracted.directory
+            : extracted.directory ?? inheritedDirectory;
+        const currentOpenApiOwner = extracted.source ? nodeId : openApiOwner;
         let newNav = nav;
         if ('pages' in newNav) {
             newNav.pages = await Promise.all(newNav.pages.map(async (page) => {
                 if (typeof page === 'object' && page !== null && 'group' in page) {
-                    return processNav(page, currentOpenApi, currentOpenApiOwner);
+                    return processNav(page, currentOpenApi, currentDirectory, currentOpenApiOwner);
                 }
                 if (typeof page !== 'string') {
                     return page;
@@ -152,7 +162,7 @@ export const generateOpenApiFromDocsConfig = async (navigation, openApiFiles, pa
                             processOpenApiWebhook(endpoint, webhookObject, schema, tempNav, tempDecoratedNav, writePromises, pagesAcc, {
                                 openApiFilePath: openApiFile.originalFileLocation,
                                 writeFiles,
-                                outDir: DEFAULT_OUTPUT_DIR,
+                                outDir: currentDirectory ?? DEFAULT_OUTPUT_DIR,
                                 outDirBasePath: path.join(targetDir ?? '', 'src', '_props'),
                                 overwrite,
                                 localSchema,
@@ -170,7 +180,7 @@ export const generateOpenApiFromDocsConfig = async (navigation, openApiFiles, pa
                             processOpenApiPath(endpoint, { [method.toLowerCase()]: opObject }, schema, tempNav, tempDecoratedNav, writePromises, pagesAcc, {
                                 openApiFilePath: openApiFile.originalFileLocation,
                                 writeFiles,
-                                outDir: DEFAULT_OUTPUT_DIR,
+                                outDir: currentDirectory ?? DEFAULT_OUTPUT_DIR,
                                 outDirBasePath: path.join(targetDir ?? '', 'src', '_props'),
                                 overwrite,
                                 localSchema,
@@ -209,7 +219,7 @@ export const generateOpenApiFromDocsConfig = async (navigation, openApiFiles, pa
                 const items = newNav[division];
                 newNav = {
                     ...newNav,
-                    [division]: await Promise.all(items.map((item) => processNav(item, currentOpenApi, currentOpenApiOwner))),
+                    [division]: await Promise.all(items.map((item) => processNav(item, currentOpenApi, currentDirectory, currentOpenApiOwner))),
                 };
             }
         }
@@ -218,10 +228,10 @@ export const generateOpenApiFromDocsConfig = async (navigation, openApiFiles, pa
         }
         return newNav;
     }
-    const navAfterExplicit = await processNav(navigation, undefined);
+    const navAfterExplicit = await processNav(navigation, undefined, undefined, undefined);
     async function generateBulkNav(node) {
         let updated = node;
-        if (extractOpenApiFromNav(updated) && !skipBulkForNode.has(updated)) {
+        if (extractOpenApiFromNav(updated).source && !skipBulkForNode.has(updated)) {
             const processed = await processOpenApiInNav(updated);
             if (processed)
                 updated = processed;