@depup/puppeteer 24.40.0-depup.0

package/src/getConfiguration.ts

@@ -0,0 +1,166 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {homedir} from 'node:os';
+import {join} from 'node:path';
+
+import {cosmiconfigSync} from 'cosmiconfig';
+import type {
+  ChromeHeadlessShellSettings,
+  ChromeSettings,
+  Configuration,
+  FirefoxSettings,
+  SupportedBrowser,
+} from 'puppeteer-core';
+
+function getBooleanEnvVar(name: string): boolean | undefined {
+  const env = process.env[name];
+  if (env === undefined) {
+    return;
+  }
+  switch (env.toLowerCase()) {
+    case '':
+    case '0':
+    case 'false':
+    case 'off':
+      return false;
+    default:
+      return true;
+  }
+}
+
+/**
+ * @internal
+ */
+function isSupportedBrowser(product: unknown): product is SupportedBrowser {
+  switch (product) {
+    case 'chrome':
+    case 'firefox':
+      return true;
+    default:
+      return false;
+  }
+}
+
+/**
+ * @internal
+ */
+function getDefaultBrowser(browser: unknown): SupportedBrowser {
+  // Validate configuration.
+  if (browser && !isSupportedBrowser(browser)) {
+    throw new Error(`Unsupported browser ${browser}`);
+  }
+  switch (browser) {
+    case 'firefox':
+      return 'firefox';
+    default:
+      return 'chrome';
+  }
+}
+
+/**
+ * @internal
+ */
+function getLogLevel(logLevel: unknown): 'silent' | 'error' | 'warn' {
+  switch (logLevel) {
+    case 'silent':
+      return 'silent';
+    case 'error':
+      return 'error';
+    default:
+      return 'warn';
+  }
+}
+
+function getBrowserSetting(
+  browser: 'chrome' | 'chrome-headless-shell' | 'firefox',
+  configuration: Configuration,
+  defaultConfig:
+    | ChromeSettings
+    | ChromeHeadlessShellSettings
+    | FirefoxSettings = {},
+): ChromeSettings | ChromeHeadlessShellSettings | FirefoxSettings {
+  if (configuration.skipDownload) {
+    return {
+      skipDownload: true,
+    };
+  }
+  const browserSetting:
+    | ChromeSettings
+    | ChromeHeadlessShellSettings
+    | FirefoxSettings = {};
+  const browserEnvName = browser.replaceAll('-', '_').toUpperCase();
+
+  browserSetting.version =
+    process.env[`PUPPETEER_${browserEnvName}_VERSION`] ??
+    configuration[browser]?.version ??
+    defaultConfig.version;
+  browserSetting.downloadBaseUrl =
+    process.env[`PUPPETEER_${browserEnvName}_DOWNLOAD_BASE_URL`] ??
+    configuration[browser]?.downloadBaseUrl ??
+    defaultConfig.downloadBaseUrl;
+
+  browserSetting.skipDownload =
+    getBooleanEnvVar(`PUPPETEER_${browserEnvName}_SKIP_DOWNLOAD`) ??
+    getBooleanEnvVar(`PUPPETEER_SKIP_${browserEnvName}_DOWNLOAD`) ??
+    configuration[browser]?.skipDownload ??
+    defaultConfig.skipDownload;
+
+  return browserSetting;
+}
+
+/**
+ * @internal
+ */
+export const getConfiguration = (): Configuration => {
+  const result = cosmiconfigSync('puppeteer', {
+    searchStrategy: 'global',
+  }).search();
+  const configuration: Configuration = result ? {...result.config} : {};
+
+  configuration.logLevel = getLogLevel(
+    process.env['PUPPETEER_LOGLEVEL'] ?? configuration.logLevel,
+  );
+
+  // Merging environment variables.
+  configuration.defaultBrowser = getDefaultBrowser(
+    process.env['PUPPETEER_BROWSER'] ?? configuration.defaultBrowser,
+  );
+
+  configuration.executablePath =
+    process.env['PUPPETEER_EXECUTABLE_PATH'] ?? configuration.executablePath;
+
+  // Default to skipDownload if executablePath is set
+  if (configuration.executablePath) {
+    configuration.skipDownload = true;
+  }
+
+  // Set skipDownload explicitly or from default
+  configuration.skipDownload =
+    getBooleanEnvVar('PUPPETEER_SKIP_DOWNLOAD') ?? configuration.skipDownload;
+
+  // Prepare variables used in browser downloading
+  configuration.chrome = getBrowserSetting('chrome', configuration);
+  configuration['chrome-headless-shell'] = getBrowserSetting(
+    'chrome-headless-shell',
+    configuration,
+  );
+  configuration.firefox = getBrowserSetting('firefox', configuration, {
+    skipDownload: true,
+  });
+
+  configuration.cacheDirectory =
+    process.env['PUPPETEER_CACHE_DIR'] ??
+    configuration.cacheDirectory ??
+    join(homedir(), '.cache', 'puppeteer');
+
+  configuration.temporaryDirectory =
+    process.env['PUPPETEER_TMP_DIR'] ?? configuration.temporaryDirectory;
+
+  configuration.experiments ??= {};
+
+  return configuration;
+};

package/src/node/cli.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {CLI, Browser} from '@puppeteer/browsers';
+import type {PuppeteerNode} from 'puppeteer-core/internal/node/PuppeteerNode.js';
+import {PUPPETEER_REVISIONS} from 'puppeteer-core/internal/revisions.js';
+import {packageVersion} from 'puppeteer-core/internal/util/version.js';
+
+import puppeteer from '../puppeteer.js';
+
+const cacheDir = (puppeteer as unknown as PuppeteerNode).configuration
+  .cacheDirectory!;
+
+void new CLI({
+  cachePath: cacheDir,
+  scriptName: 'puppeteer',
+  version: packageVersion,
+  prefixCommand: {
+    cmd: 'browsers',
+    description: 'Manage browsers of this Puppeteer installation',
+  },
+  allowCachePathOverride: false,
+  pinnedBrowsers: {
+    [Browser.CHROME]: {
+      buildId:
+        (puppeteer as unknown as PuppeteerNode).configuration.chrome?.version ||
+        PUPPETEER_REVISIONS['chrome'] ||
+        'latest',
+      skipDownload:
+        (puppeteer as unknown as PuppeteerNode).configuration.chrome
+          ?.skipDownload ?? false,
+    },
+    [Browser.FIREFOX]: {
+      buildId:
+        (puppeteer as unknown as PuppeteerNode).configuration.firefox
+          ?.version ||
+        PUPPETEER_REVISIONS['firefox'] ||
+        'latest',
+      skipDownload:
+        (puppeteer as unknown as PuppeteerNode).configuration.firefox
+          ?.skipDownload ?? true,
+    },
+    [Browser.CHROMEHEADLESSSHELL]: {
+      buildId:
+        (puppeteer as unknown as PuppeteerNode).configuration[
+          'chrome-headless-shell'
+        ]?.version ||
+        PUPPETEER_REVISIONS['chrome-headless-shell'] ||
+        'latest',
+      skipDownload:
+        (puppeteer as unknown as PuppeteerNode).configuration[
+          'chrome-headless-shell'
+        ]?.skipDownload ?? false,
+    },
+  },
+}).run(process.argv);

package/src/node/install.ts

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * Copyright 2020 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {BrowserPlatform} from '@puppeteer/browsers';
+import {
+  install,
+  Browser,
+  resolveBuildId,
+  detectBrowserPlatform,
+} from '@puppeteer/browsers';
+import type {
+  ChromeHeadlessShellSettings,
+  ChromeSettings,
+  FirefoxSettings,
+} from 'puppeteer-core';
+import {PUPPETEER_REVISIONS} from 'puppeteer-core/internal/revisions.js';
+
+import {getConfiguration} from '../getConfiguration.js';
+
+async function downloadBrowser({
+  browser,
+  configuration,
+  cacheDir,
+  platform,
+}: {
+  browser: Extract<
+    Browser,
+    Browser.CHROME | Browser.CHROMEHEADLESSSHELL | Browser.FIREFOX
+  >;
+  configuration: ChromeSettings | ChromeHeadlessShellSettings | FirefoxSettings;
+  platform: BrowserPlatform;
+  cacheDir: string;
+}) {
+  const unresolvedBuildId =
+    configuration?.version || PUPPETEER_REVISIONS[browser] || 'latest';
+  const baseUrl = configuration?.downloadBaseUrl;
+  const buildId = await resolveBuildId(browser, platform, unresolvedBuildId);
+
+  try {
+    const result = await install({
+      browser,
+      cacheDir,
+      platform,
+      buildId,
+      downloadProgressCallback: 'default',
+      baseUrl,
+      buildIdAlias:
+        buildId !== unresolvedBuildId ? unresolvedBuildId : undefined,
+    });
+    logPolitely(`${browser} (${result.buildId}) downloaded to ${result.path}`);
+  } catch (error) {
+    throw new Error(
+      `ERROR: Failed to set up ${browser} v${buildId}! Set "PUPPETEER_SKIP_DOWNLOAD" env variable to skip download.`,
+      {
+        cause: error,
+      },
+    );
+  }
+}
+
+/**
+ * @internal
+ */
+export async function downloadBrowsers(): Promise<void> {
+  overrideProxy();
+
+  const configuration = getConfiguration();
+  if (configuration.skipDownload) {
+    logPolitely('**INFO** Skipping downloading browsers as instructed.');
+    return;
+  }
+
+  const platform = detectBrowserPlatform();
+  if (!platform) {
+    throw new Error('The current platform is not supported.');
+  }
+  const cacheDir = configuration.cacheDirectory!;
+
+  const installationJobs = [];
+  if (configuration.chrome?.skipDownload) {
+    logPolitely('**INFO** Skipping Chrome download as instructed.');
+  } else {
+    const browser = Browser.CHROME;
+    installationJobs.push(
+      downloadBrowser({
+        browser,
+        configuration: configuration[browser] ?? {},
+        cacheDir,
+        platform,
+      }),
+    );
+  }
+
+  if (configuration['chrome-headless-shell']?.skipDownload) {
+    logPolitely('**INFO** Skipping Chrome download as instructed.');
+  } else {
+    const browser = Browser.CHROMEHEADLESSSHELL;
+
+    installationJobs.push(
+      downloadBrowser({
+        browser,
+        configuration: configuration[browser] ?? {},
+        cacheDir,
+        platform,
+      }),
+    );
+  }
+
+  if (configuration.firefox?.skipDownload) {
+    logPolitely('**INFO** Skipping Firefox download as instructed.');
+  } else {
+    const browser = Browser.FIREFOX;
+
+    installationJobs.push(
+      downloadBrowser({
+        browser,
+        configuration: configuration[browser] ?? {},
+        cacheDir,
+        platform,
+      }),
+    );
+  }
+
+  try {
+    await Promise.all(installationJobs);
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+/**
+ * @internal
+ */
+function logPolitely(toBeLogged: unknown): void {
+  const logLevel = process.env['npm_config_loglevel'] || '';
+  const logLevelDisplay = ['silent', 'error', 'warn'].indexOf(logLevel) > -1;
+
+  if (!logLevelDisplay) {
+    console.log(toBeLogged);
+  }
+}
+
+/**
+ * @internal
+ */
+function overrideProxy() {
+  // Override current environment proxy settings with npm configuration, if any.
+  const NPM_HTTPS_PROXY =
+    process.env['npm_config_https_proxy'] || process.env['npm_config_proxy'];
+  const NPM_HTTP_PROXY =
+    process.env['npm_config_http_proxy'] || process.env['npm_config_proxy'];
+  const NPM_NO_PROXY = process.env['npm_config_no_proxy'];
+
+  if (NPM_HTTPS_PROXY) {
+    process.env['HTTPS_PROXY'] = NPM_HTTPS_PROXY;
+  }
+  if (NPM_HTTP_PROXY) {
+    process.env['HTTP_PROXY'] = NPM_HTTP_PROXY;
+  }
+  if (NPM_NO_PROXY) {
+    process.env['NO_PROXY'] = NPM_NO_PROXY;
+  }
+}

package/src/puppeteer.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2017 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export * from 'puppeteer-core';
+
+import {PuppeteerNode} from 'puppeteer-core';
+
+import {getConfiguration} from './getConfiguration.js';
+
+const configuration = getConfiguration();
+
+/**
+ * @public
+ */
+// @ts-expect-error using internal API.
+const puppeteer = new PuppeteerNode({
+  isPuppeteerCore: false,
+  configuration,
+});
+
+export const {
+  /**
+   * @public
+   */
+  connect,
+  /**
+   * @public
+   */
+  defaultArgs,
+  /**
+   * @public
+   */
+  executablePath,
+  /**
+   * @public
+   */
+  launch,
+  /**
+   * @public
+   */
+  trimCache,
+} = puppeteer;
+
+export default puppeteer;

package/src/tsconfig.cjs.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "../lib/cjs/puppeteer"
+  }
+}

package/src/tsconfig.esm.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "../lib/esm/puppeteer"
+  }
+}