@crawlee/basic 4.0.0-beta.210 → 4.0.0-beta.212

package/internals/crawlers/context_pipeline.js

@@ -40,14 +40,14 @@ class ContextPipelineImpl extends ContextPipeline {
         return new ContextPipelineImpl(middleware, this);
     }
     chain(other) {
-        const otherMiddlewares = Array.from(other.middlewareChain()).reverse();
+        const otherMiddlewares = Array.from(other.#middlewareChain()).reverse();
         let result = this;
         for (const middleware of otherMiddlewares) {
             result = result.compose(middleware);
         }
         return result;
     }
-    *middlewareChain() {
+    *#middlewareChain() {
         let step = this;
         while (step !== undefined) {
             yield step.#middleware;
@@ -58,7 +58,7 @@ class ContextPipelineImpl extends ContextPipeline {
      * @inheritdoc
      */
     async call(crawlingContext, finalContextConsumer, onError) {
-        const middlewares = Array.from(this.middlewareChain()).reverse();
+        const middlewares = Array.from(this.#middlewareChain()).reverse();
         const cleanupStack = [];
         const onCleanup = (cleanup) => {
             cleanupStack.push(cleanup);

package/internals/crawlers/error_tracker.d.ts

@@ -39,7 +39,6 @@ export declare class ErrorTracker {
     /** The total number of errors passed to the tracker, including the same error seen repeatedly. */
     get total(): number;
     constructor(options?: Partial<ErrorTrackerOptions>);
-    private updateGroup;
     add(error: ErrnoException): void;
     /**
      * This method is async, because it captures a snapshot of the error context.

package/internals/crawlers/error_tracker.js

@@ -229,7 +229,7 @@ export class ErrorTracker {
         this.#result = Object.create(null);
         this.#total = 0;
     }
-    updateGroup(error) {
+    #updateGroup(error) {
         let group = this.#result;
         if (this.#options.showStackTrace) {
             group = getStackTraceGroup(error, group, this.#options.showFullStack);
@@ -248,7 +248,7 @@ export class ErrorTracker {
     }
     add(error) {
         this.#total++;
-        this.updateGroup(error);
+        this.#updateGroup(error);
         if (typeof error.cause === 'object' && error.cause !== null) {
             this.add(error.cause);
         }
@@ -259,7 +259,7 @@ export class ErrorTracker {
      */
     async addAsync(error, context) {
         this.#total++;
-        const group = this.updateGroup(error);
+        const group = this.#updateGroup(error);
         // Capture a snapshot (screenshot and HTML) on the first occurrence of an error
         if (group.count === 1 && context) {
             await this.#captureSnapshot(group, error, context).catch(() => { });

package/internals/crawlers/statistics.d.ts

@@ -100,7 +100,6 @@ export declare class Statistics<StateExtension extends object = {}, PersistedSta
      * Statistic instance id.
      */
     readonly id: string;
-    private readonly log;
     /**
      * Current statistic state used for doing calculations on {@link Statistics.calculate} calls
      */
@@ -156,7 +155,6 @@ export declare class Statistics<StateExtension extends object = {}, PersistedSta
      * Stops logging and remove event listeners, then persist
      */
     stopCapturing(): Promise<void>;
-    private saveRetryCountForRequest;
     /**
      * Persist internal state to the key value store.
      *

package/internals/crawlers/statistics.js

@@ -178,7 +178,7 @@ export class Statistics {
     #logIntervalMillis;
     #logMessage;
     #requestsInProgress = new Map();
-    log;
+    #log;
     #logInterval;
     /**
      * Current statistic state used for doing calculations on {@link Statistics.calculate} calls
@@ -200,7 +200,7 @@ export class Statistics {
         const { logIntervalSecs, logMessage, log, keyValueStore, persistenceOptions, saveErrorSnapshots, id, stateExtension, } = parseArgument(options, statisticsOptionsSchema);
         this.id = id ?? String(Statistics.#id++);
         this.#persistStateKey = `CRAWLEE_CRAWLER_STATISTICS_${this.id}`;
-        this.log = (log ?? serviceLocator.getLogger()).child({ prefix: 'Statistics' });
+        this.#log = (log ?? serviceLocator.getLogger()).child({ prefix: 'Statistics' });
         this.errorTracker = new ErrorTracker({ ...errorTrackerConfig, saveErrorSnapshots });
         this.errorTrackerRetry = new ErrorTracker({ ...errorTrackerConfig, saveErrorSnapshots });
         this.#logIntervalMillis = logIntervalSecs * 1000;
@@ -224,7 +224,7 @@ export class Statistics {
             persistStateKey: this.#persistStateKey,
             persistenceEnabled: persistenceOptions.enable,
             keyValueStore,
-            logger: this.log,
+            logger: this.#log,
             defaultState: () => this.#defaultState(),
             serialize: (state) => this.#serializeState(state),
             deserialize: (persistedState) => this.#deserializeState(persistedState),
@@ -337,7 +337,7 @@ export class Statistics {
         const durationMillis = record.finish();
         this.state.requestsSucceeded++;
         this.state.requestTotalSucceededDurationMillis += durationMillis;
-        this.saveRetryCountForRequest(retryCount);
+        this.#saveRetryCountForRequest(retryCount);
         if (durationMillis < this.state.requestMinDurationMillis)
             this.state.requestMinDurationMillis = durationMillis;
         if (durationMillis > this.state.requestMaxDurationMillis)
@@ -351,7 +351,7 @@ export class Statistics {
             return;
         this.state.requestTotalFailedDurationMillis += record.finish();
         this.state.requestsFailed++;
-        this.saveRetryCountForRequest(retryCount);
+        this.#saveRetryCountForRequest(retryCount);
         this.#requestsInProgress.delete(id);
     }
     /**
@@ -396,7 +396,7 @@ export class Statistics {
             this.state.crawlerStartedAt = new Date();
         }
         this.#logInterval = setInterval(() => {
-            this.log.info(this.#logMessage, {
+            this.#log.info(this.#logMessage, {
                 ...this.calculate(),
                 retryHistogram: this.requestRetryHistogram,
             });
@@ -410,7 +410,7 @@ export class Statistics {
         this.state.crawlerFinishedAt = new Date();
         await this.#recoverableState.teardown();
     }
-    saveRetryCountForRequest(retryCount) {
+    #saveRetryCountForRequest(retryCount) {
         if (retryCount > 0)
             this.state.requestsRetries++;
         this.requestRetryHistogram[retryCount] ??= 0;
@@ -425,7 +425,7 @@ export class Statistics {
     async persistState() {
         await this.#recoverableState
             .persistState()
-            .catch((error) => this.log.warning(`Failed to persist the statistics to ${this.#persistStateKey}`, { error }));
+            .catch((error) => this.#log.warning(`Failed to persist the statistics to ${this.#persistStateKey}`, { error }));
     }
     /** Rebuilds the state from a persisted record. */
     #deserializeState(persistedState) {
@@ -436,13 +436,13 @@ export class Statistics {
         if (!restored.success) {
             // Statistics are bookkeeping - a record that cannot be made sense of is worth a warning and a fresh
             // start, not a failed crawl.
-            this.log.warning('Received invalid state from Key-value store, starting the statistics from scratch.', {
+            this.#log.warning('Received invalid state from Key-value store, starting the statistics from scratch.', {
                 persistStateKey: this.#persistStateKey,
                 issues: restored.error.issues,
             });
             return this.#defaultState();
         }
-        this.log.debug('Recreating state from KeyValueStore', { persistStateKey: this.#persistStateKey });
+        this.#log.debug('Recreating state from KeyValueStore', { persistStateKey: this.#persistStateKey });
         return { ...this.#defaultState(), ...restored.data, ...this.#restoreStateExtension(persistedState) };
     }
     /**
@@ -474,7 +474,7 @@ export class Statistics {
         catch (error) {
             // Same policy as a built-in field that cannot be made sense of, but scoped to the custom ones - a
             // corrupt counter of your own is no reason to throw away the crawler's.
-            this.log.warning('Received invalid custom statistics fields from Key-value store, starting those from scratch.', { persistStateKey: this.#persistStateKey, error });
+            this.#log.warning('Received invalid custom statistics fields from Key-value store, starting those from scratch.', { persistStateKey: this.#persistStateKey, error });
             return {};
         }
     }

package/internals/crawling_request.d.ts

@@ -41,8 +41,8 @@ export interface CrawlingRequestData {
  * @category Sources
  */
 export declare class CrawlingRequest<UserData extends Dictionary = Dictionary> extends Request<UserData> {
+    #private;
     static fromSchema<UserData extends Dictionary = Dictionary>(schema: RequestSchema): CrawlingRequest<UserData>;
-    private get crawleeData();
     /**
      * Tells the crawler processing this request to skip the navigation and process the request directly.
      *

package/internals/crawling_request.js

@@ -23,7 +23,7 @@ export class CrawlingRequest extends Request {
     static fromSchema(schema) {
         return super.fromSchema(schema);
     }
-    get crawleeData() {
+    get #crawleeData() {
         return (this.userData.__crawlee ??= {});
     }
     /**
@@ -34,45 +34,45 @@ export class CrawlingRequest extends Request {
      * Accessing these properties will throw a {@link NavigationSkippedError} at runtime.
      */
     get skipNavigation() {
-        return this.crawleeData.skipNavigation ?? false;
+        return this.#crawleeData.skipNavigation ?? false;
     }
     set skipNavigation(value) {
-        this.crawleeData.skipNavigation = value;
+        this.#crawleeData.skipNavigation = value;
     }
     /**
      * Depth of the request in the current crawl tree.
      * Note that this is dependent on the crawler setup and might produce unexpected results when used with multiple crawlers.
      */
     get crawlDepth() {
-        return this.crawleeData.crawlDepth ?? 0;
+        return this.#crawleeData.crawlDepth ?? 0;
     }
     set crawlDepth(value) {
-        this.crawleeData.crawlDepth = value;
+        this.#crawleeData.crawlDepth = value;
     }
     /** ID of a session to use for this request. When set, the crawler will fetch this session from the session pool instead of creating a new one. */
     get sessionId() {
-        return this.crawleeData.sessionId;
+        return this.#crawleeData.sessionId;
     }
     set sessionId(value) {
-        this.crawleeData.sessionId = value;
+        this.#crawleeData.sessionId = value;
     }
     /** Maximum number of retries for this request. Allows to override the global `maxRequestRetries` option of `BasicCrawler`. */
     get maxRetries() {
-        return this.crawleeData.maxRetries;
+        return this.#crawleeData.maxRetries;
     }
     set maxRetries(value) {
-        this.crawleeData.maxRetries = value;
+        this.#crawleeData.maxRetries = value;
     }
     /** Describes the request's current lifecycle state. */
     get state() {
-        return this.crawleeData.state ?? RequestState.UNPROCESSED;
+        return this.#crawleeData.state ?? RequestState.UNPROCESSED;
     }
     set state(value) {
-        this.crawleeData.state = value;
+        this.#crawleeData.state = value;
     }
     /** The strategy the request was enqueued under, if it came from `enqueueLinks`. @internal */
     get enqueueStrategy() {
-        return this.crawleeData.enqueueStrategy;
+        return this.#crawleeData.enqueueStrategy;
     }
     /**
      * Stores information about an error that occurred during processing of this request.

package/internals/router.d.ts

@@ -272,15 +272,6 @@ export declare class Router<Context extends RestrictedCrawlingContext, Routes ex
      * Returns route handler for given label. If no label is provided, the default request handler will be returned.
      */
     getHandler(label?: string | symbol): (ctx: Context) => Awaitable<void>;
-    /**
-     * Validates `request.userData` against the schema registered for its label (if any), replacing it with
-     * the parsed value. Throws a {@link RequestValidationError} when validation fails.
-     */
-    private validateRequest;
-    /**
-     * Throws when the label already exists in our registry.
-     */
-    private validate;
     /**
      * Creates new router instance. This instance can then serve as a `requestHandler` of your crawler.
      *

package/internals/router.js

@@ -172,7 +172,7 @@ export class Router {
      */
     constructor() { }
     addHandler(label, handler, options = {}) {
-        this.validate(label);
+        this.#validate(label);
         this.#routes.set(label, handler);
         if (options.requestHandlerTimeoutSecs !== undefined) {
             this.#timeouts.set(label, options.requestHandlerTimeoutSecs);
@@ -187,7 +187,7 @@ export class Router {
      * through to it.
      */
     addDefaultHandler(handler, options = {}) {
-        this.validate(defaultRoute);
+        this.#validate(defaultRoute);
         this.#routes.set(defaultRoute, handler);
         if (options.requestHandlerTimeoutSecs !== undefined) {
             this.#timeouts.set(defaultRoute, options.requestHandlerTimeoutSecs);
@@ -259,7 +259,7 @@ export class Router {
      * Validates `request.userData` against the schema registered for its label (if any), replacing it with
      * the parsed value. Throws a {@link RequestValidationError} when validation fails.
      */
-    async validateRequest(context) {
+    async #validateRequest(context) {
         const label = context.request.label;
         const schema = this.getSchema(label);
         if (schema) {
@@ -269,7 +269,7 @@ export class Router {
     /**
      * Throws when the label already exists in our registry.
      */
-    validate(label) {
+    #validate(label) {
         if (this.#routes.has(label)) {
             const message = label === defaultRoute
                 ? `Default route is already defined!`
@@ -300,7 +300,7 @@ export class Router {
         const func = async function (context) {
             const { url, loadedUrl, label } = context.request;
             context.log.debug('Page opened.', { label, url: loadedUrl ?? url });
-            await router.validateRequest(context);
+            await router.#validateRequest(context);
             for (const middleware of router.#middlewares) {
                 await middleware(context);
             }

package/internals/session_pool/session.d.ts

@@ -148,9 +148,4 @@ export declare class Session implements ISession {
      * Sets a cookie within this session for the specific URL.
      */
     setCookie(rawCookie: string, url: string): Promise<void>;
-    /**
-     * Makes an unusable session's state terminal. Unlike `retire()`, this leaves the error score alone so that
-     * `isBlocked()` keeps telling a burned identity from one that merely ran out of uses.
-     */
-    private maybeSelfRetire;
 }

package/internals/session_pool/session.js

@@ -146,7 +146,7 @@ export class Session {
         if (this.#errorScore > 0) {
             this.#errorScore -= this.#errorScoreDecrement;
         }
-        this.maybeSelfRetire();
+        this.#maybeSelfRetire();
     }
     /**
      * Gets session state for persistence in KeyValueStore.
@@ -191,7 +191,7 @@ export class Session {
     markBad() {
         this.#errorScore += 1;
         this.#usageCount += 1;
-        this.maybeSelfRetire();
+        this.#maybeSelfRetire();
     }
     /**
      * Returns cookies saved with the session in the typical
@@ -217,7 +217,7 @@ export class Session {
      * Makes an unusable session's state terminal. Unlike `retire()`, this leaves the error score alone so that
      * `isBlocked()` keeps telling a burned identity from one that merely ran out of uses.
      */
-    maybeSelfRetire() {
+    #maybeSelfRetire() {
         if (!this.isUsable()) {
             this.#retired = true;
         }

package/internals/session_pool/session_pool.d.ts

@@ -133,12 +133,6 @@ export declare class SessionPool implements ISessionPool {
      * Gets count of retired sessions in the pool.
      */
     retiredSessionsCount(): Promise<number>;
-    /**
-     * Starts periodic state persistence and potentially loads SessionPool state from {@link KeyValueStore}.
-     * Called automatically on first use of any public method.
-     */
-    private ensureInitialized;
-    private setupPool;
     /**
      * Adds a new session to the session pool. The pool automatically creates sessions up to the maximum size of the pool,
      * but this allows you to add more sessions once the max pool size is reached.
@@ -195,50 +189,5 @@ export declare class SessionPool implements ISessionPool {
      * Using the pool again afterwards initializes it anew.
      */
     teardown(): Promise<void>;
-    /**
-     * Removes retired `Session` instances from `SessionPool`.
-     */
-    private removeRetiredSessions;
-    /**
-     * Adds `Session` instance to `SessionPool`.
-     * @param newSession `Session` instance to be added.
-     */
-    private registerSession;
-    /**
-     * Gets random index.
-     */
-    private getRandomIndex;
-    /**
-     * Creates new session without any extra behavior.
-     * @param [options]
-     * @param [options.sessionOptions] The configuration options for the session being created.
-     * @returns New session.
-     */
-    private defaultCreateSessionFunction;
-    /**
-     * Invokes `createSessionFunction` with `sessionOptions` already merged from pool-wide defaults and
-     * the supplied per-call overrides, so custom implementations don't need to spread `pool.sessionOptions` themselves.
-     *
-     * A default {@link SessionFingerprint} is generated up front (host OS as
-     * `platform`, a random valid `browser`/`device` for that platform). Pool-wide
-     * and per-call options override it, and a persisted fingerprint coming
-     * through `maybeLoadSessionPool` naturally wins because it arrives in
-     * `perCallOptions`.
-     */
-    private invokeCreateSessionFunction;
-    /**
-     * Creates new session and adds it to the pool.
-     * @returns Newly created `Session` instance.
-     */
-    private createSession;
-    /**
-     * Decides whether there is enough space for creating new session.
-     */
-    private hasSpaceForSession;
-    /**
-     * Picks a session from the `SessionPool` according to the configured `sessionReuseStrategy`.
-     * Returns `undefined` when no session should be reused and a new one should be created instead.
-     */
-    private pickSession;
 }
 export {};

package/internals/session_pool/session_pool.js

@@ -151,7 +151,7 @@ export class SessionPool {
         this.#persistenceOptions = persistenceOptions;
         // Pool Configuration
         this.#maxPoolSize = maxPoolSize;
-        this.#createSessionFunction = createSessionFunction || this.defaultCreateSessionFunction;
+        this.#createSessionFunction = createSessionFunction || this.#defaultCreateSessionFunction;
         // Session configuration. The pool-scoped logger is merged into per-call sessionOptions inside
         // `invokeCreateSessionFunction`, so every Session inherits it without custom createSessionFunctions
         // having to know about it.
@@ -163,7 +163,7 @@ export class SessionPool {
         this.#persistStateKeyValueStoreId = persistStateKeyValueStoreId;
         this.#persistStateKey = persistStateKey ?? `${PERSIST_STATE_KEY}_${this.id}`;
         this.#stateCodec = buildSessionPoolStateCodec({
-            recreateSession: (sessionState) => this.invokeCreateSessionFunction(sessionState),
+            recreateSession: (sessionState) => this.#invokeCreateSessionFunction(sessionState),
             toRecord: (sessions) => this.#buildPersistedState(sessions),
             log: this.#log,
         });
@@ -185,27 +185,27 @@ export class SessionPool {
      * Gets count of usable sessions in the pool.
      */
     async usableSessionsCount() {
-        await this.ensureInitialized();
+        await this.#ensureInitialized();
         return this.#state.currentValue.sessions.filter((session) => session.isUsable()).length;
     }
     /**
      * Gets count of retired sessions in the pool.
      */
     async retiredSessionsCount() {
-        await this.ensureInitialized();
+        await this.#ensureInitialized();
         return this.#state.currentValue.sessions.filter((session) => !session.isUsable()).length;
     }
     /**
      * Starts periodic state persistence and potentially loads SessionPool state from {@link KeyValueStore}.
      * Called automatically on first use of any public method.
      */
-    async ensureInitialized() {
+    async #ensureInitialized() {
         if (!this.#initPromise) {
-            this.#initPromise = this.setupPool();
+            this.#initPromise = this.#setupPool();
         }
         return this.#initPromise;
     }
-    async setupPool() {
+    async #setupPool() {
         await this.#state.initialize();
         for (const session of this.#state.currentValue.sessions) {
             this.#sessionMap.set(session.id, session);
@@ -221,7 +221,7 @@ export class SessionPool {
      * @param [options] The configuration options for the session being added to the session pool.
      */
     async addSession(options = {}) {
-        await this.ensureInitialized();
+        await this.#ensureInitialized();
         const { id } = options;
         if (id) {
             const existingSession = this.#sessionMap.get(id);
@@ -232,12 +232,12 @@ export class SessionPool {
                 this.#removeSession(existingSession);
             }
         }
-        if (!this.hasSpaceForSession()) {
-            this.removeRetiredSessions();
+        if (!this.#hasSpaceForSession()) {
+            this.#removeRetiredSessions();
         }
-        const newSession = options instanceof Session ? options : await this.invokeCreateSessionFunction(options);
+        const newSession = options instanceof Session ? options : await this.#invokeCreateSessionFunction(options);
         this.#log.debug(`Adding new Session - ${newSession.id}`);
-        this.registerSession(newSession);
+        this.#registerSession(newSession);
     }
     /**
      * Adds a new session to the session pool. The pool automatically creates sessions up to the maximum size of the pool,
@@ -246,9 +246,9 @@ export class SessionPool {
      * @param [options] The configuration options for the session being added to the session pool.
      */
     async newSession(sessionOptions) {
-        await this.ensureInitialized();
-        const newSession = await this.invokeCreateSessionFunction(sessionOptions);
-        this.registerSession(newSession);
+        await this.#ensureInitialized();
+        const newSession = await this.#invokeCreateSessionFunction(sessionOptions);
+        this.#registerSession(newSession);
         return newSession;
     }
     /**
@@ -259,7 +259,7 @@ export class SessionPool {
      * @param [sessionId] If provided, it returns the usable session with this id, `undefined` otherwise.
      */
     async getSession(sessionId) {
-        await this.ensureInitialized();
+        await this.#ensureInitialized();
         await this.#queue.wait();
         try {
             if (sessionId) {
@@ -268,14 +268,14 @@ export class SessionPool {
                     return session;
                 return undefined;
             }
-            const pickedSession = this.pickSession();
+            const pickedSession = this.#pickSession();
             if (pickedSession)
                 return pickedSession;
-            if (this.hasSpaceForSession()) {
-                return await this.createSession();
+            if (this.#hasSpaceForSession()) {
+                return await this.#createSession();
             }
-            this.removeRetiredSessions();
-            return await this.createSession();
+            this.#removeRetiredSessions();
+            return await this.#createSession();
         }
         finally {
             this.#queue.shift();
@@ -306,7 +306,7 @@ export class SessionPool {
      * @internal
      */
     async getState() {
-        await this.ensureInitialized();
+        await this.#ensureInitialized();
         return this.#buildPersistedState(this.#state.currentValue.sessions);
     }
     /**
@@ -317,7 +317,7 @@ export class SessionPool {
         if (!this.#persistenceOptions.enable) {
             return;
         }
-        await this.ensureInitialized();
+        await this.#ensureInitialized();
         this.#log.debug('Persisting state', {
             persistStateKeyValueStoreId: this.#persistStateKeyValueStoreId,
             persistStateKey: this.#persistStateKey,
@@ -337,7 +337,7 @@ export class SessionPool {
     async teardown() {
         if (!this.#initPromise)
             return;
-        await this.ensureInitialized();
+        await this.#ensureInitialized();
         await this.#state.teardown();
         // The next use initializes the pool again, restoring the record and resuming the periodic persistence -
         // a crawler that is run twice gets a persisting pool both times.
@@ -346,7 +346,7 @@ export class SessionPool {
     /**
      * Removes retired `Session` instances from `SessionPool`.
      */
-    removeRetiredSessions() {
+    #removeRetiredSessions() {
         this.#state.currentValue.sessions = this.#state.currentValue.sessions.filter((storedSession) => {
             if (storedSession.isUsable())
                 return true;
@@ -367,14 +367,14 @@ export class SessionPool {
      * Adds `Session` instance to `SessionPool`.
      * @param newSession `Session` instance to be added.
      */
-    registerSession(newSession) {
+    #registerSession(newSession) {
         this.#state.currentValue.sessions.push(newSession);
         this.#sessionMap.set(newSession.id, newSession);
     }
     /**
      * Gets random index.
      */
-    getRandomIndex() {
+    #getRandomIndex() {
         return Math.floor(Math.random() * this.#state.currentValue.sessions.length);
     }
     /**
@@ -383,7 +383,7 @@ export class SessionPool {
      * @param [options.sessionOptions] The configuration options for the session being created.
      * @returns New session.
      */
-    async defaultCreateSessionFunction(options = {}) {
+    async #defaultCreateSessionFunction(options = {}) {
         const { sessionOptions } = parseArgument(options, createSessionOptionsSchema);
         return new Session(sessionOptions);
     }
@@ -397,7 +397,7 @@ export class SessionPool {
      * through `maybeLoadSessionPool` naturally wins because it arrives in
      * `perCallOptions`.
      */
-    async invokeCreateSessionFunction(perCallOptions) {
+    async #invokeCreateSessionFunction(perCallOptions) {
         const sessionOptions = {
             fingerprint: createDefaultSessionFingerprint(),
             ...this.#sessionOptions,
@@ -409,24 +409,24 @@ export class SessionPool {
      * Creates new session and adds it to the pool.
      * @returns Newly created `Session` instance.
      */
-    async createSession() {
-        const newSession = await this.invokeCreateSessionFunction();
-        this.registerSession(newSession);
+    async #createSession() {
+        const newSession = await this.#invokeCreateSessionFunction();
+        this.#registerSession(newSession);
         this.#log.debug(`Created new Session - ${newSession.id}`);
         return newSession;
     }
     /**
      * Decides whether there is enough space for creating new session.
      */
-    hasSpaceForSession() {
+    #hasSpaceForSession() {
         return this.#state.currentValue.sessions.length < this.#maxPoolSize;
     }
     /**
      * Picks a session from the `SessionPool` according to the configured `sessionReuseStrategy`.
      * Returns `undefined` when no session should be reused and a new one should be created instead.
      */
-    pickSession() {
-        if (this.#sessionReuseStrategy !== 'use-until-failure' && this.hasSpaceForSession())
+    #pickSession() {
+        if (this.#sessionReuseStrategy !== 'use-until-failure' && this.#hasSpaceForSession())
             return undefined;
         if (this.#sessionReuseStrategy === 'use-until-failure') {
             return this.#state.currentValue.sessions.find((session) => session.isUsable());
@@ -438,7 +438,7 @@ export class SessionPool {
             picked = this.#state.currentValue.sessions[index];
         }
         else {
-            picked = this.#state.currentValue.sessions[this.getRandomIndex()];
+            picked = this.#state.currentValue.sessions[this.#getRandomIndex()];
         }
         return picked.isUsable() ? picked : undefined;
     }