@mintlify/prebuild 1.0.797 → 1.0.799

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;
     }
 }