@shopify/cli-hydrogen 8.1.0 → 8.2.0

package/dist/index.d.ts

@@ -90,29 +90,29 @@ declare class Dev extends Command {
         worker: {
             type: "option";
             name: string;
-            char?: _oclif_core_lib_interfaces_alphabet_js.AlphabetLowercase | _oclif_core_lib_interfaces_alphabet_js.AlphabetUppercase | undefined;
-            summary?: string | undefined;
-            description?: string | undefined;
-            helpLabel?: string | undefined;
-            helpGroup?: string | undefined;
-            env?: string | undefined;
-            hidden?: boolean | undefined;
-            required?: boolean | undefined;
-            dependsOn?: string[] | undefined;
-            exclusive?: string[] | undefined;
-            exactlyOne?: string[] | undefined;
-            relationships?: _oclif_core_lib_interfaces_parser_js.Relationship[] | undefined;
-            deprecated?: true | _oclif_core_lib_interfaces_parser_js.Deprecation | undefined;
-            aliases?: string[] | undefined;
-            charAliases?: (_oclif_core_lib_interfaces_alphabet_js.AlphabetLowercase | _oclif_core_lib_interfaces_alphabet_js.AlphabetUppercase)[] | undefined;
-            deprecateAliases?: boolean | undefined;
-            noCacheDefault?: boolean | undefined;
-            helpValue?: string | undefined;
-            options?: readonly string[] | undefined;
-            multiple?: boolean | undefined;
-            multipleNonGreedy?: boolean | undefined;
-            delimiter?: "," | undefined;
-            allowStdin?: boolean | "only" | undefined;
+            char?: _oclif_core_lib_interfaces_alphabet_js.AlphabetLowercase | _oclif_core_lib_interfaces_alphabet_js.AlphabetUppercase;
+            summary?: string;
+            description?: string;
+            helpLabel?: string;
+            helpGroup?: string;
+            env?: string;
+            hidden?: boolean;
+            required?: boolean;
+            dependsOn?: string[];
+            exclusive?: string[];
+            exactlyOne?: string[];
+            relationships?: _oclif_core_lib_interfaces_parser_js.Relationship[];
+            deprecated?: true | _oclif_core_lib_interfaces_parser_js.Deprecation;
+            aliases?: string[];
+            charAliases?: (_oclif_core_lib_interfaces_alphabet_js.AlphabetLowercase | _oclif_core_lib_interfaces_alphabet_js.AlphabetUppercase)[];
+            deprecateAliases?: boolean;
+            noCacheDefault?: boolean;
+            helpValue?: string;
+            options?: readonly string[];
+            multiple?: boolean;
+            multipleNonGreedy?: boolean;
+            delimiter?: ",";
+            allowStdin?: boolean | "only";
             parse: _oclif_core_lib_interfaces_parser_js.FlagParser<unknown, string, _oclif_core_lib_interfaces_parser_js.CustomOptions>;
             defaultHelp?: unknown;
             input: string[];
@@ -262,29 +262,29 @@ declare class Preview extends Command {
         worker: {
             type: "option";
             name: string;
-            char?: _oclif_core_lib_interfaces_alphabet_js.AlphabetLowercase | _oclif_core_lib_interfaces_alphabet_js.AlphabetUppercase | undefined;
-            summary?: string | undefined;
-            description?: string | undefined;
-            helpLabel?: string | undefined;
-            helpGroup?: string | undefined;
-            env?: string | undefined;
-            hidden?: boolean | undefined;
-            required?: boolean | undefined;
-            dependsOn?: string[] | undefined;
-            exclusive?: string[] | undefined;
-            exactlyOne?: string[] | undefined;
-            relationships?: _oclif_core_lib_interfaces_parser_js.Relationship[] | undefined;
-            deprecated?: true | _oclif_core_lib_interfaces_parser_js.Deprecation | undefined;
-            aliases?: string[] | undefined;
-            charAliases?: (_oclif_core_lib_interfaces_alphabet_js.AlphabetLowercase | _oclif_core_lib_interfaces_alphabet_js.AlphabetUppercase)[] | undefined;
-            deprecateAliases?: boolean | undefined;
-            noCacheDefault?: boolean | undefined;
-            helpValue?: string | undefined;
-            options?: readonly string[] | undefined;
-            multiple?: boolean | undefined;
-            multipleNonGreedy?: boolean | undefined;
-            delimiter?: "," | undefined;
-            allowStdin?: boolean | "only" | undefined;
+            char?: _oclif_core_lib_interfaces_alphabet_js.AlphabetLowercase | _oclif_core_lib_interfaces_alphabet_js.AlphabetUppercase;
+            summary?: string;
+            description?: string;
+            helpLabel?: string;
+            helpGroup?: string;
+            env?: string;
+            hidden?: boolean;
+            required?: boolean;
+            dependsOn?: string[];
+            exclusive?: string[];
+            exactlyOne?: string[];
+            relationships?: _oclif_core_lib_interfaces_parser_js.Relationship[];
+            deprecated?: true | _oclif_core_lib_interfaces_parser_js.Deprecation;
+            aliases?: string[];
+            charAliases?: (_oclif_core_lib_interfaces_alphabet_js.AlphabetLowercase | _oclif_core_lib_interfaces_alphabet_js.AlphabetUppercase)[];
+            deprecateAliases?: boolean;
+            noCacheDefault?: boolean;
+            helpValue?: string;
+            options?: readonly string[];
+            multiple?: boolean;
+            multipleNonGreedy?: boolean;
+            delimiter?: ",";
+            allowStdin?: boolean | "only";
             parse: _oclif_core_lib_interfaces_parser_js.FlagParser<unknown, string, _oclif_core_lib_interfaces_parser_js.CustomOptions>;
             defaultHelp?: unknown;
             input: string[];

package/dist/lib/auth.js

@@ -21,8 +21,7 @@ async function login(root, shop) {
   if (typeof shop !== "string") {
     shop = existingConfig.shop;
   }
-  if (shop)
-    shop = await normalizeStoreFqdn(shop);
+  if (shop) shop = await normalizeStoreFqdn(shop);
   const hideLoginInfo = showLoginInfo();
   if (!shop || !shopName || !email || forcePrompt || shop !== existingConfig.shop) {
     const token = await ensureAuthenticatedBusinessPlatform().catch(() => {

package/dist/lib/build.js

@@ -43,8 +43,7 @@ async function getTemplateAppFile(filepath, root) {
   return url.protocol === "file:" ? fileURLToPath(url) : url.toString();
 }
 function getStarterDir(useSource = !!process.env.SHOPIFY_UNIT_TEST) {
-  if (useSource)
-    return getSkeletonSourceDir();
+  if (useSource) return getSkeletonSourceDir();
   return getAssetsDir(ASSETS_STARTER_DIR);
 }
 function getSkeletonSourceDir() {

package/dist/lib/bundle/analyzer.js

@@ -4,24 +4,25 @@ import colors from '@shopify/cli-kit/node/colors';
 import { renderWarning } from '@shopify/cli-kit/node/ui';
 import { getAssetsDir } from '../build.js';
 
-async function buildBundleAnalysis(buildPath) {
+const BUNDLE_ANALYZER_JSON_FILE = "metafile.server.json";
+const BUNDLE_ANALYZER_HTML_FILE = "server-bundle-analyzer.html";
+async function classicBuildBundleAnalysis(buildPath) {
   const workerBuildPath = joinPath(buildPath, "worker");
-  const serverMetafile = "metafile.server.json";
+  const serverMetafile = BUNDLE_ANALYZER_JSON_FILE;
   const clientMetafile = "metafile.js.json";
   const hasMetafile = (await Promise.all([
     fileExists(joinPath(workerBuildPath, serverMetafile)),
     fileExists(joinPath(workerBuildPath, clientMetafile))
   ])).every(Boolean);
-  if (!hasMetafile)
-    return null;
+  if (!hasMetafile) return null;
   try {
     await Promise.all([
-      writeBundleAnalyzerFile(
+      classicWriteBundleAnalyzerFile(
         workerBuildPath,
         serverMetafile,
         "worker-bundle-analyzer.html"
       ),
-      writeBundleAnalyzerFile(
+      classicWriteBundleAnalyzerFile(
         workerBuildPath,
         clientMetafile,
         "client-bundle-analyzer.html"
@@ -37,34 +38,48 @@ async function buildBundleAnalysis(buildPath) {
     return null;
   }
 }
-async function writeBundleAnalyzerFile(workerBuildPath, metafileName, outputFile) {
+async function getAnalyzerTemplate() {
+  return readFile(await getAssetsDir("bundle", "analyzer.html"));
+}
+function injectAnalyzerTemplateData(analysisTemplate, metafile) {
+  return analysisTemplate.replace(
+    `globalThis.METAFILE = '';`,
+    `globalThis.METAFILE = '${Buffer.from(metafile, "utf-8").toString(
+      "base64"
+    )}';`
+  );
+}
+async function classicWriteBundleAnalyzerFile(workerBuildPath, metafileName, outputFile) {
   const metafile = await readFile(joinPath(workerBuildPath, metafileName), {
     encoding: "utf8"
   });
-  const metafile64 = Buffer.from(metafile, "utf-8").toString("base64");
-  const analysisTemplate = await readFile(
-    await getAssetsDir("bundle", "analyzer.html")
+  await writeFile(
+    joinPath(workerBuildPath, outputFile),
+    injectAnalyzerTemplateData(await getAnalyzerTemplate(), metafile)
   );
-  const templateWithMetafile = analysisTemplate.replace(
-    `globalThis.METAFILE = '';`,
-    `globalThis.METAFILE = '${metafile64}';`
-  );
-  await writeFile(joinPath(workerBuildPath, outputFile), templateWithMetafile);
 }
-async function getBundleAnalysisSummary(bundlePath) {
-  const esbuild = await import('esbuild').catch(() => {
-  });
-  if (esbuild) {
-    const metafilePath = joinPath(dirname(bundlePath), "metafile.server.json");
-    return "    \u2502\n " + (await esbuild.analyzeMetafile(await readFile(metafilePath), {
-      color: true
-    })).split("\n").filter((line) => {
+async function getBundleAnalysisSummary(distPath) {
+  try {
+    const esbuild = await import('esbuild');
+    const metafileAnalysis = await esbuild.analyzeMetafile(
+      await readFile(joinPath(distPath, BUNDLE_ANALYZER_JSON_FILE)),
+      { color: true }
+    );
+    return "    \u2502\n " + metafileAnalysis.split("\n").filter((line) => {
       const match = line.match(
         /(.*)(node_modules\/|server-assets-manifest:|server-entry-module:)(react-dom|@remix-run|@shopify\/hydrogen|react-router|react-router-dom)\/(.*)/g
       );
       return !match;
     }).slice(2, 12).join("\n").replace(/dist\/worker\/_assets\/.*$/ms, "\n").replace(/\n/g, "\n ").replace(/(\.\.\/)+node_modules\//g, (match) => colors.dim(match));
+  } catch (error) {
+    console.warn(
+      "Could not generate bundle analysis summary:",
+      error.message
+    );
   }
 }
+function classicGetBundleAnalysisSummary(bundlePath) {
+  return getBundleAnalysisSummary(dirname(bundlePath));
+}
 
-export { buildBundleAnalysis, getBundleAnalysisSummary };
+export { BUNDLE_ANALYZER_HTML_FILE, BUNDLE_ANALYZER_JSON_FILE, classicBuildBundleAnalysis, classicGetBundleAnalysisSummary, getAnalyzerTemplate, getBundleAnalysisSummary, injectAnalyzerTemplateData };

package/dist/lib/bundle/vite-plugin.js

@@ -0,0 +1,161 @@
+import { relativePath, joinPath } from '@shopify/cli-kit/node/path';
+import { getAnalyzerTemplate, BUNDLE_ANALYZER_JSON_FILE, BUNDLE_ANALYZER_HTML_FILE, injectAnalyzerTemplateData } from './analyzer.js';
+
+function hydrogenBundleAnalyzer(pluginOptions) {
+  let config;
+  return {
+    name: "hydrogen:bundle-analyzer",
+    configResolved(_config) {
+      config = _config;
+    },
+    async generateBundle(options, bundle) {
+      if (!config.build.ssr) return;
+      const { root } = config;
+      const workerFile = Object.values(bundle).find(
+        (chunk) => chunk.type === "chunk"
+      );
+      if (!workerFile || workerFile.type !== "chunk" || !workerFile.facadeModuleId || !options.dir) {
+        return;
+      }
+      const analysisTemplate = await getAnalyzerTemplate().catch(() => null);
+      if (!analysisTemplate) {
+        console.warn("Bundle analyzer template not found");
+        return;
+      }
+      const allModIds = new Set(Object.keys(workerFile.modules));
+      const modsToAnalyze = [];
+      for (const modId of allModIds) {
+        if (isViteCjsHelper(modId) || isViteTransformHelper(modId)) continue;
+        const mod = this.getModuleInfo(modId);
+        if (!mod?.id) continue;
+        modsToAnalyze.push(mod);
+        for (const importedId of [
+          ...mod.importedIds,
+          ...mod.dynamicallyImportedIds
+        ]) {
+          if (!isViteCjsHelper(importedId) && !isViteTransformHelper(importedId)) {
+            allModIds.add(importedId);
+          }
+        }
+      }
+      const modsMeta = /* @__PURE__ */ new Map();
+      const renderedSizes = /* @__PURE__ */ new Map();
+      const resultError = await Promise.all(
+        modsToAnalyze.map(async (mod) => {
+          const relativeModId = relativePath(root, mod.id);
+          const modBundleInfo = workerFile.modules[mod.id];
+          const originalCodeBytes = modBundleInfo?.originalLength ?? mod.code?.length ?? 0;
+          let resultingCodeBytes = modBundleInfo?.renderedLength ?? 0;
+          if (pluginOptions?.minify && modBundleInfo?.code) {
+            const minifiedCode = await pluginOptions.minify(modBundleInfo.code, mod.id).catch(() => null);
+            if (minifiedCode) resultingCodeBytes = minifiedCode.length;
+          }
+          renderedSizes.set(relativeModId, resultingCodeBytes);
+          const resolveImportString = (importString) => this.resolve(importString, mod.id);
+          let isESM = !mod.code || /(^\s*export\s+[\w\{]|^\s*import\s+[\w\{'"]|\bimport\()|\bcreateRequire\(/ms.test(
+            mod.code
+          ) || !/((^|\b)exports\b|\brequire\()/.test(mod.code);
+          const staticImportsMeta = createImportsMeta(
+            mod.importedIds,
+            "import-statement",
+            root,
+            resolveImportString,
+            mod.code
+          );
+          const dynamicImportsMeta = createImportsMeta(
+            mod.dynamicallyImportedIds,
+            "dynamic-import",
+            root,
+            resolveImportString,
+            mod.code
+          );
+          const importsMeta = (await Promise.all([...staticImportsMeta, ...dynamicImportsMeta])).reduce((acc, { importedId, ...meta }) => {
+            if (isViteCjsHelper(importedId)) {
+              isESM = false;
+            } else if (!isViteTransformHelper(importedId)) {
+              acc.push(meta);
+            }
+            return acc;
+          }, []);
+          modsMeta.set(relativeModId, {
+            bytes: originalCodeBytes,
+            format: isESM ? "esm" : "cjs",
+            imports: importsMeta
+          });
+        })
+      ).then(() => null).catch((error) => error);
+      if (resultError) {
+        console.warn(
+          "Bundle analyzer failed to analyze the bundle:",
+          resultError
+        );
+        return;
+      }
+      const inputs = Object.fromEntries(modsMeta.entries());
+      const metafile = {
+        inputs,
+        outputs: {
+          [relativePath(root, joinPath(options.dir, workerFile.fileName))]: {
+            imports: workerFile.imports,
+            exports: workerFile.exports,
+            entryPoint: relativePath(root, workerFile.facadeModuleId),
+            bytes: workerFile.code.length ?? 0,
+            inputs: Object.entries(inputs).reduce((acc, [key, item]) => {
+              acc[key] = {
+                bytesInOutput: renderedSizes.get(key) ?? item.bytes ?? 0
+              };
+              return acc;
+            }, {})
+          }
+        }
+      };
+      bundle[BUNDLE_ANALYZER_JSON_FILE] = {
+        type: "asset",
+        fileName: BUNDLE_ANALYZER_JSON_FILE,
+        name: BUNDLE_ANALYZER_JSON_FILE,
+        needsCodeReference: false,
+        source: JSON.stringify(metafile, null, 2)
+      };
+      bundle[BUNDLE_ANALYZER_HTML_FILE] = {
+        type: "asset",
+        fileName: BUNDLE_ANALYZER_HTML_FILE,
+        name: BUNDLE_ANALYZER_HTML_FILE,
+        needsCodeReference: false,
+        source: injectAnalyzerTemplateData(
+          analysisTemplate,
+          JSON.stringify(metafile)
+        )
+      };
+    }
+  };
+}
+function isViteCjsHelper(id) {
+  return /(commonjsHelpers\.js$|\?commonjs\-)/.test(id);
+}
+function isViteTransformHelper(id) {
+  return id.endsWith("?transform-only");
+}
+async function findOriginalImportName(filepath, importerCode, resolve) {
+  const matches = importerCode.matchAll(/import\s[^'"]*?['"]([^'"]+)['"]/g) ?? [];
+  for (const [, match] of matches) {
+    if (match) {
+      const resolvedMod = await resolve(match);
+      if (resolvedMod?.id === filepath) {
+        return match;
+      }
+    }
+  }
+  return filepath;
+}
+function createImportsMeta(ids, kind, root, resolveImportString, code) {
+  return ids.map(async (importedId) => {
+    return {
+      importedId,
+      path: relativePath(root, importedId),
+      kind,
+      original: code ? await findOriginalImportName(importedId, code, resolveImportString) : importedId
+    };
+  });
+}
+
+export { hydrogenBundleAnalyzer };

package/dist/lib/check-cli-version.js

@@ -0,0 +1,61 @@
+import { fileURLToPath } from 'node:url';
+import { findUpAndReadPackageJson, checkForNewVersion, packageManagerFromUserAgent } from '@shopify/cli-kit/node/node-package-manager';
+import { renderInfo } from '@shopify/cli-kit/node/ui';
+import { isHydrogenMonorepo } from './build.js';
+import { inferPackageManagerForGlobalCLI } from '@shopify/cli-kit/node/is-global';
+
+const UPGRADABLE_CLI_NAMES = {
+  cli: "@shopify/cli",
+  cliHydrogen: "@shopify/cli-hydrogen",
+  createApp: "@shopify/create-hydrogen"
+};
+async function checkCurrentCLIVersion() {
+  if (isHydrogenMonorepo && !process.env.SHOPIFY_UNIT_TEST) return;
+  const { content: pkgJson } = await findUpAndReadPackageJson(
+    fileURLToPath(import.meta.url)
+  ).catch(() => ({ content: void 0 }));
+  const pkgName = pkgJson?.name;
+  const currentVersion = pkgJson?.version;
+  if (!pkgName || !currentVersion || !Object.values(UPGRADABLE_CLI_NAMES).some((name) => name === pkgName) || currentVersion.includes("next") || currentVersion.includes("experimental") || currentVersion.includes("snapshot")) {
+    return;
+  }
+  const newVersionAvailable = await checkForNewVersion(pkgName, currentVersion);
+  if (!newVersionAvailable) return;
+  const reference = [
+    {
+      link: {
+        label: "Hydrogen releases",
+        url: "https://github.com/Shopify/hydrogen/releases"
+      }
+    }
+  ];
+  if (pkgName === UPGRADABLE_CLI_NAMES.cli) {
+    reference.push({
+      link: {
+        label: "Global CLI reference",
+        url: "https://shopify.dev/docs/api/shopify-cli/"
+      }
+    });
+  }
+  return (packageManager) => {
+    packageManager ??= packageManagerFromUserAgent();
+    if (packageManager === "unknown" || !packageManager) {
+      packageManager = inferPackageManagerForGlobalCLI();
+    }
+    if (packageManager === "unknown") {
+      packageManager = "npm";
+    }
+    const installMessage = pkgName === UPGRADABLE_CLI_NAMES.cli ? `Please install the latest Shopify CLI version with \`${packageManager === "yarn" ? `yarn global add ${UPGRADABLE_CLI_NAMES.cli}` : `${packageManager} install -g ${UPGRADABLE_CLI_NAMES.cli}`}\` and try again.` : `Please use the latest version with \`${packageManager} create @shopify/hydrogen@latest\``;
+    renderInfo({
+      headline: "Upgrade available",
+      body: `Version ${newVersionAvailable} of ${pkgName} is now available.
+You are currently running v${currentVersion}.
+
+` + installMessage,
+      reference
+    });
+    return { currentVersion, newVersion: newVersionAvailable };
+  };
+}
+
+export { UPGRADABLE_CLI_NAMES, checkCurrentCLIVersion };

package/dist/lib/check-lockfile.js

@@ -4,6 +4,7 @@ import { checkIfIgnoredInGitRepository } from '@shopify/cli-kit/node/git';
 import { renderWarning } from '@shopify/cli-kit/node/ui';
 import { AbortError } from '@shopify/cli-kit/node/error';
 import { packageManagers } from './package-managers.js';
+import { isHydrogenMonorepo } from './build.js';
 
 function missingLockfileWarning(shouldExit) {
   const headline = "No lockfile found";
@@ -53,8 +54,7 @@ function lockfileIgnoredWarning(lockfile) {
   renderWarning({ headline, body, nextSteps });
 }
 async function checkLockfileStatus(directory, shouldExit = false) {
-  if (process.env.LOCAL_DEV)
-    return;
+  if (isHydrogenMonorepo && !process.env.SHOPIFY_UNIT_TEST) return;
   const foundPackageManagers = [];
   for (const packageManager of packageManagers) {
     if (await fileExists(resolvePath(directory, packageManager.lockfile))) {

package/dist/lib/classic-compiler/build.js

@@ -8,7 +8,7 @@ import { checkLockfileStatus } from '../check-lockfile.js';
 import { findMissingRoutes } from '../missing-routes.js';
 import { muteRemixLogs, createRemixLogger } from '../log.js';
 import { codegen } from '../codegen.js';
-import { buildBundleAnalysis, getBundleAnalysisSummary } from '../bundle/analyzer.js';
+import { classicBuildBundleAnalysis, classicGetBundleAnalysisSummary } from '../bundle/analyzer.js';
 import { isCI } from '../is-ci.js';
 import { importLocal } from '../import-utils.js';
 
@@ -76,7 +76,7 @@ async function runClassicCompilerBuild({
   ]);
   if (process.env.NODE_ENV !== "development") {
     console.timeEnd(LOG_WORKER_BUILT);
-    const bundleAnalysisPath = await buildBundleAnalysis(buildPath);
+    const bundleAnalysisPath = await classicBuildBundleAnalysis(buildPath);
     const sizeMB = await fileSize(buildPathWorkerFile) / (1024 * 1024);
     const formattedSize = colors.yellow(sizeMB.toFixed(2) + " MB");
     outputInfo(
@@ -86,7 +86,7 @@ async function runClassicCompilerBuild({
     );
     if (bundleStats && bundleAnalysisPath) {
       outputInfo(
-        outputContent`${await getBundleAnalysisSummary(buildPathWorkerFile) || "\n"}\n    │\n    └─── ${outputToken.link(
+        outputContent`${await classicGetBundleAnalysisSummary(buildPathWorkerFile) || "\n"}\n    │\n    └─── ${outputToken.link(
           "Complete analysis: " + bundleAnalysisPath,
           bundleAnalysisPath
         )}\n\n`

package/dist/lib/classic-compiler/dev.js

@@ -39,12 +39,9 @@ async function runClassicCompilerDev({
   cliConfig,
   verbose
 }) {
-  if (!process.env.NODE_ENV)
-    process.env.NODE_ENV = "development";
-  if (verbose)
-    setH2OVerbose();
-  if (!isH2Verbose())
-    muteDevLogs();
+  if (!process.env.NODE_ENV) process.env.NODE_ENV = "development";
+  if (verbose) setH2OVerbose();
+  if (!isH2Verbose()) muteDevLogs();
   const { root, publicPath, buildPathClient, buildPathWorkerFile } = getProjectPaths(appPath);
   const copyFilesPromise = copyPublicFiles(publicPath, buildPathClient);
   const cliCommandPromise = getCliCommand(root);
@@ -111,8 +108,7 @@ async function runClassicCompilerDev({
   let miniOxygen;
   let codegenProcess;
   async function safeStartMiniOxygen() {
-    if (miniOxygen)
-      return;
+    if (miniOxygen) return;
     const { allVariables, logInjectedVariables } = await envPromise;
     miniOxygen = await startMiniOxygen(
       {
@@ -183,8 +179,7 @@ async function runClassicCompilerDev({
         } else if (!skipRebuildLogs) {
           skipRebuildLogs = false;
           console.timeEnd(LOG_REBUILT);
-          if (!miniOxygen)
-            console.log("");
+          if (!miniOxygen) console.log("");
         }
         if (!miniOxygen && !await serverBundleExists()) {
           return renderFatalError({

package/dist/lib/codegen.js

@@ -22,8 +22,7 @@ function normalizeCodegenError(errorMessage, rootDirectory) {
     const parsedError = errorMessage.split("AbortError: ")[1] ?? "";
     const message2 = parsedError.split("\n")[0];
     const details2 = parsedError.match(/tryMessage: '(.*)',$/m)?.[1];
-    if (message2)
-      return { message: message2, details: details2 };
+    if (message2) return { message: message2, details: details2 };
   }
   const [first = "", ...rest] = errorMessage.replaceAll("[FAILED]", "").replace(/\s{2,}/g, "\n").replace(/\n,\n/, "\n").trim().split("\n");
   const message = "[Codegen] " + first;
@@ -66,15 +65,11 @@ function spawnCodegenProcess({
   const child = spawn(command, args, { stdio: ["inherit", "ignore", "pipe"] });
   child.stderr.on("data", (data) => {
     const dataString = typeof data === "string" ? data : data?.toString?.("utf8") ?? "";
-    if (!dataString)
-      return;
+    if (!dataString) return;
     const { message, details } = normalizeCodegenError(dataString, rootDirectory);
-    if (/`punycode`/.test(message))
-      return;
-    if (/\.body\[\d\]/.test(message))
-      return;
-    if (/console\.time(End)?\(\)/.test(message))
-      return;
+    if (/`punycode`/.test(message)) return;
+    if (/\.body\[\d\]/.test(message)) return;
+    if (/console\.time(End)?\(\)/.test(message)) return;
     console.log("");
     renderWarning({ headline: message, body: details });
   });
@@ -90,8 +85,7 @@ function spawnCodegenProcess({
 }
 function codegen(options) {
   return generateTypes(options).catch((error) => {
-    if (error instanceof AbortError)
-      throw error;
+    if (error instanceof AbortError) throw error;
     const { message, details } = normalizeCodegenError(
       error.message,
       options.rootDirectory
@@ -117,8 +111,7 @@ async function generateTypes({
   const { config: codegenConfig } = (
     // Load <root>/codegen.ts if available
     await loadCodegenConfig({
-      configFilePath,
-      searchPlaces: [dirs.rootDirectory]
+      configFilePath: configFilePath ?? dirs.rootDirectory
     }) || // Fall back to default config
     await generateDefaultConfig(dirs, forceSfapiVersion)
   );
@@ -223,8 +216,7 @@ async function generateDefaultConfig({
   };
 }
 function findGqlProject(schemaFilepath, gqlConfig) {
-  if (!gqlConfig)
-    return;
+  if (!gqlConfig) return;
   const schemaFilename = basename(schemaFilepath);
   return Object.values(gqlConfig.projects || {}).find(
     (project) => typeof project.schema === "string" && project.schema.endsWith(schemaFilename)

package/dist/lib/defer.js

@@ -2,13 +2,11 @@ function deferPromise() {
   const deferred = { state: "pending" };
   deferred.promise = new Promise((resolve, reject) => {
     deferred.resolve = (value) => {
-      if (deferred.state === "pending")
-        deferred.state = "resolved";
+      if (deferred.state === "pending") deferred.state = "resolved";
       return resolve(value);
     };
     deferred.reject = (reason) => {
-      if (deferred.state === "pending")
-        deferred.state = "rejected";
+      if (deferred.state === "pending") deferred.state = "rejected";
       return reject(reason);
     };
   });

package/dist/lib/environment-variables.js

@@ -76,10 +76,8 @@ async function getRemoteVariables(root, envHandle, envBranch) {
   const remoteVariables = {};
   const remoteSecrets = {};
   for (const { key, value, isSecret } of envVariables) {
-    if (isSecret)
-      remoteSecrets[key] = value;
-    else
-      remoteVariables[key] = value;
+    if (isSecret) remoteSecrets[key] = value;
+    else remoteVariables[key] = value;
   }
   return { remoteVariables, remoteSecrets };
 }