nest-puppeteer 1.1.0 → 3.0.0

package/dist/index.cjs

@@ -0,0 +1,298 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  InjectBrowser: () => InjectBrowser,
+  InjectContext: () => InjectContext,
+  InjectPage: () => InjectPage,
+  PuppeteerModule: () => PuppeteerModule,
+  getBrowserToken: () => getBrowserToken,
+  getContextToken: () => getContextToken,
+  getPageToken: () => getPageToken
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/puppeteer.decorators.ts
+var import_common = require("@nestjs/common");
+
+// src/puppeteer.constants.ts
+var PUPPETEER_INSTANCE_NAME = "PuppeteerInstanceName";
+var PUPPETEER_MODULE_OPTIONS = "PuppeteerModuleOptions";
+var DEFAULT_PUPPETEER_INSTANCE_NAME = "DefaultPuppeteer";
+var args = [
+  "--allow-insecure-localhost",
+  // Enables TLS/SSL errors on localhost to be ignored (no interstitial, no blocking of requests).
+  "--allow-http-screen-capture",
+  // Allow non-secure origins to use the screen capture API and the desktopCapture extension API.
+  "--no-zygote"
+  // https://codereview.chromium.org/2384163002
+];
+if (typeof process.getuid === "function") {
+  args.push("--no-sandbox");
+}
+var DEFAULT_CHROME_LAUNCH_OPTIONS = {
+  headless: true,
+  pipe: process.platform !== "win32",
+  args
+};
+
+// src/puppeteer.util.ts
+function getBrowserToken(instanceName = DEFAULT_PUPPETEER_INSTANCE_NAME) {
+  return `${instanceName}Browser`;
+}
+function getContextToken(instanceName = DEFAULT_PUPPETEER_INSTANCE_NAME) {
+  return `${instanceName}Context`;
+}
+function getPageToken(instanceName = DEFAULT_PUPPETEER_INSTANCE_NAME) {
+  return `${instanceName}Page`;
+}
+
+// src/puppeteer.decorators.ts
+var InjectBrowser = (instanceName) => (0, import_common.Inject)(getBrowserToken(instanceName));
+var InjectContext = (instanceName) => (0, import_common.Inject)(getContextToken(instanceName));
+var InjectPage = (instanceName) => (0, import_common.Inject)(getPageToken(instanceName));
+
+// src/puppeteer.module.ts
+var import_common3 = require("@nestjs/common");
+
+// src/puppeteer.providers.ts
+function createPuppeteerProviders(instanceName, pages = []) {
+  return pages.map((page) => ({
+    provide: getPageToken(page),
+    useFactory: (context) => context.newPage(),
+    inject: [getContextToken(instanceName)]
+  }));
+}
+
+// src/puppeteer-core.module.ts
+var import_common2 = require("@nestjs/common");
+var import_puppeteer = __toESM(require("puppeteer"), 1);
+var PuppeteerCoreModule = class {
+  constructor(instanceName, moduleRef) {
+    this.instanceName = instanceName;
+    this.moduleRef = moduleRef;
+  }
+  onApplicationShutdown() {
+    return this.onModuleDestroy();
+  }
+  static forRoot(launchOptions = DEFAULT_CHROME_LAUNCH_OPTIONS, instanceName = DEFAULT_PUPPETEER_INSTANCE_NAME) {
+    const instanceNameProvider = {
+      provide: PUPPETEER_INSTANCE_NAME,
+      useValue: instanceName
+    };
+    const browserProvider = {
+      provide: getBrowserToken(instanceName),
+      async useFactory() {
+        return await import_puppeteer.default.launch(launchOptions);
+      }
+    };
+    const contextProvider = {
+      provide: getContextToken(instanceName),
+      async useFactory(browser) {
+        return browser.createBrowserContext();
+      },
+      inject: [getBrowserToken(instanceName)]
+    };
+    const pageProvider = {
+      provide: getPageToken(instanceName),
+      async useFactory(context) {
+        return await context.newPage();
+      },
+      inject: [getContextToken(instanceName)]
+    };
+    return {
+      module: PuppeteerCoreModule,
+      providers: [instanceNameProvider, browserProvider, contextProvider, pageProvider],
+      exports: [browserProvider, contextProvider, pageProvider]
+    };
+  }
+  static forRootAsync(options) {
+    const puppeteerInstanceName = options.instanceName ?? DEFAULT_PUPPETEER_INSTANCE_NAME;
+    const instanceNameProvider = {
+      provide: PUPPETEER_INSTANCE_NAME,
+      useValue: puppeteerInstanceName
+    };
+    const browserProvider = {
+      provide: getBrowserToken(puppeteerInstanceName),
+      async useFactory(puppeteerModuleOptions) {
+        return await import_puppeteer.default.launch(
+          puppeteerModuleOptions.launchOptions ?? DEFAULT_CHROME_LAUNCH_OPTIONS
+        );
+      },
+      inject: [PUPPETEER_MODULE_OPTIONS]
+    };
+    const contextProvider = {
+      provide: getContextToken(puppeteerInstanceName),
+      async useFactory(browser) {
+        return await browser.createBrowserContext();
+      },
+      inject: [getBrowserToken(puppeteerInstanceName)]
+    };
+    const pageProvider = {
+      provide: getPageToken(puppeteerInstanceName),
+      async useFactory(context) {
+        return await context.newPage();
+      },
+      inject: [getContextToken(puppeteerInstanceName)]
+    };
+    const asyncProviders = this.createAsyncProviders(options);
+    return {
+      module: PuppeteerCoreModule,
+      imports: options.imports,
+      providers: [
+        ...asyncProviders,
+        browserProvider,
+        contextProvider,
+        pageProvider,
+        instanceNameProvider
+      ],
+      exports: [browserProvider, contextProvider, pageProvider]
+    };
+  }
+  async onModuleDestroy() {
+    const browser = this.moduleRef.get(getBrowserToken(this.instanceName));
+    if (browser?.isConnected()) await browser.close();
+  }
+  static createAsyncProviders(options) {
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncOptionsProvider(options)];
+    } else if (options.useClass) {
+      return [
+        this.createAsyncOptionsProvider(options),
+        {
+          provide: options.useClass,
+          useClass: options.useClass
+        }
+      ];
+    } else {
+      return [];
+    }
+  }
+  static createAsyncOptionsProvider(options) {
+    if (options.useFactory) {
+      return {
+        provide: PUPPETEER_MODULE_OPTIONS,
+        useFactory: options.useFactory,
+        inject: options.inject ?? []
+      };
+    } else if (options.useExisting) {
+      return {
+        provide: PUPPETEER_MODULE_OPTIONS,
+        async useFactory(optionsFactory) {
+          return optionsFactory.createPuppeteerOptions();
+        },
+        inject: [options.useExisting]
+      };
+    } else if (options.useClass) {
+      return {
+        provide: PUPPETEER_MODULE_OPTIONS,
+        async useFactory(optionsFactory) {
+          return optionsFactory.createPuppeteerOptions();
+        },
+        inject: [options.useClass]
+      };
+    } else {
+      throw new Error("Invalid PuppeteerModule options");
+    }
+  }
+};
+PuppeteerCoreModule = __decorateClass([
+  (0, import_common2.Global)(),
+  (0, import_common2.Module)({}),
+  __decorateParam(0, (0, import_common2.Inject)(PUPPETEER_INSTANCE_NAME))
+], PuppeteerCoreModule);
+
+// src/puppeteer.module.ts
+var PuppeteerModule = class {
+  /**
+   * Inject the Puppeteer synchronously.
+   * @param options Options for the Browser to be launched
+   * @param instanceName A unique name for the connection.  If not specified, a default name
+   * will be used.
+   */
+  static forRoot(options, instanceName) {
+    const { isGlobal, ...launchOptions } = options ?? {};
+    const effectiveLaunchOptions = Object.keys(launchOptions).length > 0 ? launchOptions : void 0;
+    return {
+      module: PuppeteerModule,
+      global: isGlobal,
+      imports: [PuppeteerCoreModule.forRoot(effectiveLaunchOptions, instanceName)]
+    };
+  }
+  /**
+   * Inject the Puppeteer asynchronously, allowing any dependencies such as a configuration
+   * service to be injected first.
+   * @param options Options for asynchronous injection
+   */
+  static forRootAsync(options) {
+    return {
+      module: PuppeteerModule,
+      global: options.isGlobal,
+      imports: [PuppeteerCoreModule.forRootAsync(options)]
+    };
+  }
+  /**
+   * Inject Pages.
+   * @param pages An array of the names of the pages to be injected.
+   * @param instanceName A unique name for the connection. If not specified, a default name
+   * will be used.
+   */
+  static forFeature(pages = [], instanceName) {
+    const providers = createPuppeteerProviders(instanceName, pages);
+    return {
+      module: PuppeteerModule,
+      providers,
+      exports: providers
+    };
+  }
+};
+PuppeteerModule = __decorateClass([
+  (0, import_common3.Module)({})
+], PuppeteerModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InjectBrowser,
+  InjectContext,
+  InjectPage,
+  PuppeteerModule,
+  getBrowserToken,
+  getContextToken,
+  getPageToken
+});

package/dist/index.d.cts

@@ -0,0 +1,103 @@
+import { ModuleMetadata, Type, InjectionToken, DynamicModule } from '@nestjs/common';
+import { LaunchOptions } from 'puppeteer';
+
+/**
+ * Inject the Browser object associated with a connection
+ * @param instanceName The unique name associated with the browser
+ */
+declare const InjectBrowser: (instanceName?: string) => PropertyDecorator & ParameterDecorator;
+/**
+ * Inject the Puppeteer BrowserContext object associated with a browser
+ * @param instanceName The unique name associated with the browser
+ */
+declare const InjectContext: (instanceName?: string) => PropertyDecorator & ParameterDecorator;
+/**
+ * Inject the Puppeteer Page object associated with BrowserContext
+ * @param instanceName The unique name associated with the instance
+ */
+declare const InjectPage: (instanceName?: string) => PropertyDecorator & ParameterDecorator;
+
+/**
+ * Options that ultimately need to be provided to create a Puppeteer instance
+ */
+interface PuppeteerModuleOptions {
+    instanceName?: string;
+    launchOptions?: LaunchOptions;
+}
+interface PuppeteerOptionsFactory {
+    createPuppeteerOptions(): Promise<PuppeteerModuleOptions> | PuppeteerModuleOptions;
+}
+/**
+ * Options available when creating the module asynchronously.  You should use only one of the
+ * useExisting, useClass, or useFactory options for creation.
+ */
+interface PuppeteerModuleAsyncOptions extends Pick<ModuleMetadata, "imports"> {
+    /** A unique name for the instance.  If not specified, a default one will be used. */
+    instanceName?: string;
+    /**
+     * If "true", registers `PuppeteerModule` as a global module.
+     * See: https://docs.nestjs.com/modules#global-modules
+     */
+    isGlobal?: boolean;
+    /** Reuse an injectable factory class created in another module. */
+    useExisting?: Type<PuppeteerOptionsFactory>;
+    /**
+     * Use an injectable factory class to populate the module options, such as URI and database name.
+     */
+    useClass?: Type<PuppeteerOptionsFactory>;
+    /**
+     * A factory function that will populate the module options, such as URI and database name.
+     */
+    useFactory?: (...args: unknown[]) => Promise<PuppeteerModuleOptions> | PuppeteerModuleOptions;
+    /**
+     * Inject any dependencies required by the Puppeteer module, such as a configuration service
+     * that supplies the options and instance name
+     */
+    inject?: InjectionToken[];
+}
+
+/**
+ * Module for the Puppeteer
+ */
+declare class PuppeteerModule {
+    /**
+     * Inject the Puppeteer synchronously.
+     * @param options Options for the Browser to be launched
+     * @param instanceName A unique name for the connection.  If not specified, a default name
+     * will be used.
+     */
+    static forRoot(options?: PuppeteerModuleOptions["launchOptions"] & {
+        isGlobal?: boolean;
+    }, instanceName?: string): DynamicModule;
+    /**
+     * Inject the Puppeteer asynchronously, allowing any dependencies such as a configuration
+     * service to be injected first.
+     * @param options Options for asynchronous injection
+     */
+    static forRootAsync(options: PuppeteerModuleAsyncOptions): DynamicModule;
+    /**
+     * Inject Pages.
+     * @param pages An array of the names of the pages to be injected.
+     * @param instanceName A unique name for the connection. If not specified, a default name
+     * will be used.
+     */
+    static forFeature(pages?: string[], instanceName?: string): DynamicModule;
+}
+
+/**
+ * Get a token for the Puppeteer instance for the given Browser name
+ * @param instanceName The unique name for the Puppeteer instance
+ */
+declare function getBrowserToken(instanceName?: string): string;
+/**
+ * Get a token for the Puppeteer instance for the given BrowserContext name
+ * @param instanceName The unique name for the Puppeteer instance
+ */
+declare function getContextToken(instanceName?: string): string;
+/**
+ * Get a token for the Puppeteer instance for the given Page name
+ * @param instanceName The unique name for the Puppeteer instance
+ */
+declare function getPageToken(instanceName?: string): string;
+
+export { InjectBrowser, InjectContext, InjectPage, PuppeteerModule, type PuppeteerModuleAsyncOptions, type PuppeteerModuleOptions, type PuppeteerOptionsFactory, getBrowserToken, getContextToken, getPageToken };

package/dist/index.d.ts

@@ -1,4 +1,103 @@
-export * from './puppeteer.decorators';
-export * from './puppeteer.module';
-export * from './puppeteer.util';
-export * from './interfaces';
+import { ModuleMetadata, Type, InjectionToken, DynamicModule } from '@nestjs/common';
+import { LaunchOptions } from 'puppeteer';
+
+/**
+ * Inject the Browser object associated with a connection
+ * @param instanceName The unique name associated with the browser
+ */
+declare const InjectBrowser: (instanceName?: string) => PropertyDecorator & ParameterDecorator;
+/**
+ * Inject the Puppeteer BrowserContext object associated with a browser
+ * @param instanceName The unique name associated with the browser
+ */
+declare const InjectContext: (instanceName?: string) => PropertyDecorator & ParameterDecorator;
+/**
+ * Inject the Puppeteer Page object associated with BrowserContext
+ * @param instanceName The unique name associated with the instance
+ */
+declare const InjectPage: (instanceName?: string) => PropertyDecorator & ParameterDecorator;
+
+/**
+ * Options that ultimately need to be provided to create a Puppeteer instance
+ */
+interface PuppeteerModuleOptions {
+    instanceName?: string;
+    launchOptions?: LaunchOptions;
+}
+interface PuppeteerOptionsFactory {
+    createPuppeteerOptions(): Promise<PuppeteerModuleOptions> | PuppeteerModuleOptions;
+}
+/**
+ * Options available when creating the module asynchronously.  You should use only one of the
+ * useExisting, useClass, or useFactory options for creation.
+ */
+interface PuppeteerModuleAsyncOptions extends Pick<ModuleMetadata, "imports"> {
+    /** A unique name for the instance.  If not specified, a default one will be used. */
+    instanceName?: string;
+    /**
+     * If "true", registers `PuppeteerModule` as a global module.
+     * See: https://docs.nestjs.com/modules#global-modules
+     */
+    isGlobal?: boolean;
+    /** Reuse an injectable factory class created in another module. */
+    useExisting?: Type<PuppeteerOptionsFactory>;
+    /**
+     * Use an injectable factory class to populate the module options, such as URI and database name.
+     */
+    useClass?: Type<PuppeteerOptionsFactory>;
+    /**
+     * A factory function that will populate the module options, such as URI and database name.
+     */
+    useFactory?: (...args: unknown[]) => Promise<PuppeteerModuleOptions> | PuppeteerModuleOptions;
+    /**
+     * Inject any dependencies required by the Puppeteer module, such as a configuration service
+     * that supplies the options and instance name
+     */
+    inject?: InjectionToken[];
+}
+
+/**
+ * Module for the Puppeteer
+ */
+declare class PuppeteerModule {
+    /**
+     * Inject the Puppeteer synchronously.
+     * @param options Options for the Browser to be launched
+     * @param instanceName A unique name for the connection.  If not specified, a default name
+     * will be used.
+     */
+    static forRoot(options?: PuppeteerModuleOptions["launchOptions"] & {
+        isGlobal?: boolean;
+    }, instanceName?: string): DynamicModule;
+    /**
+     * Inject the Puppeteer asynchronously, allowing any dependencies such as a configuration
+     * service to be injected first.
+     * @param options Options for asynchronous injection
+     */
+    static forRootAsync(options: PuppeteerModuleAsyncOptions): DynamicModule;
+    /**
+     * Inject Pages.
+     * @param pages An array of the names of the pages to be injected.
+     * @param instanceName A unique name for the connection. If not specified, a default name
+     * will be used.
+     */
+    static forFeature(pages?: string[], instanceName?: string): DynamicModule;
+}
+
+/**
+ * Get a token for the Puppeteer instance for the given Browser name
+ * @param instanceName The unique name for the Puppeteer instance
+ */
+declare function getBrowserToken(instanceName?: string): string;
+/**
+ * Get a token for the Puppeteer instance for the given BrowserContext name
+ * @param instanceName The unique name for the Puppeteer instance
+ */
+declare function getContextToken(instanceName?: string): string;
+/**
+ * Get a token for the Puppeteer instance for the given Page name
+ * @param instanceName The unique name for the Puppeteer instance
+ */
+declare function getPageToken(instanceName?: string): string;
+
+export { InjectBrowser, InjectContext, InjectPage, PuppeteerModule, type PuppeteerModuleAsyncOptions, type PuppeteerModuleOptions, type PuppeteerOptionsFactory, getBrowserToken, getContextToken, getPageToken };