@mintlify/previewing 4.0.1461 → 4.0.1463

package/dist/packages/setup.js

@@ -0,0 +1,81 @@
+import { parsePackageJsonDependencies } from '@mintlify/common';
+import { getConfigObj } from '@mintlify/prebuild';
+import { packagesSchema } from '@mintlify/validation';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { errnoCode } from './errno.js';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+export class DocsJsonError extends Error {
+    constructor(problems) {
+        super(problems.join('\n'));
+        this.problems = problems;
+    }
+}
+export class InvalidPackagesError extends DocsJsonError {
+    constructor(problems, variables) {
+        super(problems);
+        this.variables = variables;
+    }
+}
+const messageOf = (error) => (error instanceof Error ? error.message : String(error));
+const readText = async (path) => {
+    try {
+        return { content: await readFile(path, 'utf8') };
+    }
+    catch (error) {
+        if (errnoCode(error) === 'ENOENT')
+            return {};
+        return { error: `could not be read: ${messageOf(error)}` };
+    }
+};
+export const normalizeProviderPath = (provider) => `/${provider.replace(/\\/g, '/').replace(/^\/+/, '')}`;
+const readVariables = (value) => {
+    if (!isRecord(value))
+        return undefined;
+    const variables = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry === 'string')
+            variables[key] = entry;
+    }
+    return variables;
+};
+export const readPackagesSetup = async (docsRoot) => {
+    let docsConfig;
+    try {
+        docsConfig = await getConfigObj(docsRoot, 'docs');
+    }
+    catch (error) {
+        throw new DocsJsonError([`docs.json could not be loaded: ${messageOf(error)}`]);
+    }
+    if (docsConfig === null)
+        return undefined;
+    if (!isRecord(docsConfig))
+        throw new DocsJsonError(['docs.json is not a JSON object']);
+    if (!('packages' in docsConfig))
+        return undefined;
+    const parsed = packagesSchema.safeParse(docsConfig.packages);
+    if (!parsed.success) {
+        throw new InvalidPackagesError(parsed.error.issues.map((issue) => `docs.json ${['packages', ...issue.path].join('.')}: ${issue.message}`), readVariables(docsConfig.variables));
+    }
+    const packages = parsed.data;
+    if (packages.provider !== undefined)
+        packages.provider = normalizeProviderPath(packages.provider);
+    const errors = [];
+    const packageJson = await readText(join(docsRoot, 'package.json'));
+    const dependencies = packageJson.content === undefined
+        ? undefined
+        : parsePackageJsonDependencies(packageJson.content);
+    const problem = packageJson.error ?? dependencies?.error;
+    const packageJsonError = problem && `package.json ${problem}`;
+    if (packageJsonError)
+        errors.push(packageJsonError);
+    else if (!dependencies)
+        errors.push('docs.json sets "packages" but there is no package.json next to it.');
+    return {
+        packages,
+        packageNames: dependencies?.error ? new Set() : (dependencies?.packageNames ?? new Set()),
+        variables: readVariables(docsConfig.variables),
+        errors,
+        ...(packageJsonError && { packageJsonError }),
+    };
+};