@mintlify/previewing 4.0.523 → 4.0.525

package/dist/local-preview/client.d.ts

@@ -0,0 +1,5 @@
+import type { Ora as OraType } from 'ora';
+export declare const getTargetMintVersion: (logger: OraType) => Promise<string | undefined>;
+export declare const fallbackMintClient: (logger: OraType, versionString: string) => Promise<void>;
+export declare const extractMintClient: (logger: OraType) => Promise<void>;
+export declare const downloadTargetMint: (logger: OraType, targetMintVersion: string, versionString: string | null, clientVersion: string | undefined) => Promise<void>;

package/dist/local-preview/client.js

@@ -0,0 +1,90 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fse from 'fs-extra';
+import got from 'got';
+import isOnline from 'is-online';
+import { pipeline } from 'node:stream/promises';
+import tar from 'tar';
+import { DOT_MINTLIFY, VERSION_PATH, MINT_PATH, TAR_PATH, TARGET_MINT_VERSION_URL, GET_TAR_URL, } from '../constants.js';
+export const getTargetMintVersion = (logger) => __awaiter(void 0, void 0, void 0, function* () {
+    const hasInternet = yield isOnline();
+    if (!hasInternet) {
+        return undefined;
+    }
+    try {
+        const response = yield got(TARGET_MINT_VERSION_URL);
+        return response.body;
+    }
+    catch (error) {
+        logger.text = `Failed to fetch the latest Mintlify version: ${error instanceof Error ? error.message : 'Unknown error'}`;
+        return undefined;
+    }
+});
+export const fallbackMintClient = (logger, versionString) => __awaiter(void 0, void 0, void 0, function* () {
+    logger.text = `Using version: ${versionString}`;
+    const oldTarUrl = GET_TAR_URL(versionString);
+    try {
+        yield pipeline(got.stream(oldTarUrl), fse.createWriteStream(TAR_PATH));
+    }
+    catch (error) {
+        logger.fail(`Failed to download Mintlify framework version ${versionString}, ${error}`);
+        process.exit(1);
+    }
+    try {
+        yield extractMintClient(logger);
+    }
+    catch (error) {
+        logger.fail(`Failed to extract Mintlify framework version ${versionString}, ${error}`);
+        process.exit(1);
+    }
+});
+export const extractMintClient = (logger) => __awaiter(void 0, void 0, void 0, function* () {
+    logger.text = 'Extracting Mintlify framework...';
+    tar.x({
+        sync: true,
+        file: TAR_PATH,
+        cwd: DOT_MINTLIFY,
+        onwarn: (_code, message, _data) => {
+            throw new Error(message);
+        },
+    });
+});
+export const downloadTargetMint = (logger, targetMintVersion, versionString, clientVersion) => __awaiter(void 0, void 0, void 0, function* () {
+    fse.emptyDirSync(MINT_PATH);
+    logger.text = 'Downloading Mintlify framework...';
+    const tarUrl = clientVersion ? GET_TAR_URL(clientVersion) : GET_TAR_URL(targetMintVersion);
+    let currentVersion = clientVersion || targetMintVersion;
+    try {
+        yield pipeline(got.stream(tarUrl), fse.createWriteStream(TAR_PATH));
+    }
+    catch (error) {
+        if (versionString) {
+            currentVersion = versionString;
+            yield fallbackMintClient(logger, versionString);
+        }
+        else {
+            process.exit(1);
+        }
+    }
+    try {
+        yield extractMintClient(logger);
+    }
+    catch (error) {
+        if (versionString && currentVersion !== versionString) {
+            currentVersion = versionString;
+            yield fallbackMintClient(logger, versionString);
+        }
+        else {
+            process.exit(1);
+        }
+    }
+    fse.removeSync(TAR_PATH);
+    fse.writeFileSync(VERSION_PATH, targetMintVersion);
+});

package/dist/local-preview/index.js

@@ -12,63 +12,14 @@ import open from 'better-opn';
 import Chalk from 'chalk';
 import express from 'express';
 import fse, { pathExists } from 'fs-extra';
-import got from 'got';
 import { createServer } from 'http';
 import isOnline from 'is-online';
-import { pipeline } from 'node:stream/promises';
 import { pathToFileURL } from 'node:url';
 import { Server as SocketServer } from 'socket.io';
-import tar from 'tar';
-import { CLIENT_PATH, DOT_MINTLIFY, CMD_EXEC_PATH, VERSION_PATH, MINT_PATH, NEXT_CONFIG_PATH, TAR_PATH, NEXT_PUBLIC_PATH, NEXT_PROPS_PATH, NEXT_SIDE_EFFECT_PATH, NEXT_ROUTER_SERVER_PATH, TARGET_MINT_VERSION_URL, GET_TAR_URL, } from '../constants.js';
+import { CLIENT_PATH, DOT_MINTLIFY, CMD_EXEC_PATH, VERSION_PATH, NEXT_CONFIG_PATH, NEXT_PUBLIC_PATH, NEXT_PROPS_PATH, NEXT_SIDE_EFFECT_PATH, NEXT_ROUTER_SERVER_PATH, } from '../constants.js';
 import { buildLogger, maybeFixMissingWindowsEnvVar } from '../util.js';
+import { getTargetMintVersion, downloadTargetMint } from './client.js';
 import listener from './listener/index.js';
-const getTargetMintVersion = (logger) => __awaiter(void 0, void 0, void 0, function* () {
-    const hasInternet = yield isOnline();
-    if (!hasInternet) {
-        return undefined;
-    }
-    try {
-        const response = yield got(TARGET_MINT_VERSION_URL);
-        return response.body;
-    }
-    catch (error) {
-        logger.text = `Failed to fetch the latest Mintlify version: ${error instanceof Error ? error.message : 'Unknown error'}`;
-        return undefined;
-    }
-});
-const downloadTargetMint = (logger, targetMintVersion, versionString) => __awaiter(void 0, void 0, void 0, function* () {
-    fse.emptyDirSync(MINT_PATH);
-    logger.text = 'Downloading Mintlify framework...';
-    const tarUrl = GET_TAR_URL(targetMintVersion);
-    try {
-        yield pipeline(got.stream(tarUrl), fse.createWriteStream(TAR_PATH));
-    }
-    catch (error) {
-        logger.text = `Failed to download Mintlify framework version ${targetMintVersion}, ${error}`;
-        if (versionString) {
-            logger.text = `Using version: ${versionString}`;
-            const oldTarUrl = GET_TAR_URL(versionString);
-            try {
-                yield pipeline(got.stream(oldTarUrl), fse.createWriteStream(TAR_PATH));
-            }
-            catch (error) {
-                logger.fail(`Failed to download Mintlify framework version ${versionString}, ${error}`);
-                process.exit(1);
-            }
-        }
-        else {
-            process.exit(1);
-        }
-    }
-    logger.text = 'Extracting Mintlify framework...';
-    tar.x({
-        sync: true,
-        file: TAR_PATH,
-        cwd: DOT_MINTLIFY,
-    });
-    fse.removeSync(TAR_PATH);
-    fse.writeFileSync(VERSION_PATH, targetMintVersion);
-});
 const dev = (argv) => __awaiter(void 0, void 0, void 0, function* () {
     // Note: We wait for specific text in the logger to be sure the server is ready when we e2e test the cli.
     // If the cli output does not exactly match:
@@ -76,6 +27,8 @@ const dev = (argv) => __awaiter(void 0, void 0, void 0, function* () {
     // the test will fail/require an update.
     const logger = buildLogger('Preparing local Mintlify instance...');
     const hasInternet = yield isOnline();
+    const localSchema = argv['local-schema'];
+    const clientVersion = argv['client-version'];
     yield fse.ensureDir(DOT_MINTLIFY);
     const versionString = (yield pathExists(VERSION_PATH))
         ? fse.readFileSync(VERSION_PATH, 'utf8')
@@ -91,15 +44,14 @@ const dev = (argv) => __awaiter(void 0, void 0, void 0, function* () {
                 versionString +
                 ', which may not be the latest Mintlify client version.';
     }
-    const shouldDownload = versionString !== targetMintVersion;
+    const shouldDownload = versionString !== targetMintVersion || clientVersion !== undefined;
     if (shouldDownload && hasInternet && targetMintVersion) {
-        yield downloadTargetMint(logger, targetMintVersion, versionString);
+        yield downloadTargetMint(logger, targetMintVersion, versionString, clientVersion);
     }
     // clear preexisting prebuild files
     fse.emptyDirSync(NEXT_PUBLIC_PATH);
     fse.emptyDirSync(NEXT_PROPS_PATH);
     process.chdir(CLIENT_PATH);
-    const localSchema = argv['local-schema'];
     try {
         yield prebuild(CMD_EXEC_PATH, { localSchema });
     }