smart-load-manager 1.0.0

package/dist/index.cjs

@@ -0,0 +1,394 @@
+'use strict';
+
+var decorators_js = require('@exadel/esl/modules/esl-utils/decorators.js');
+var async_js = require('@exadel/esl/modules/esl-utils/async.js');
+var dom_js = require('@exadel/esl/modules/esl-utils/dom.js');
+
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = __getOwnPropDesc$1(target, key) ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp$2(target, key, result);
+  return result;
+};
+var __async$2 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function applyEarlyHints(options) {
+  const link = document.createElement("link");
+  link.rel = options.rel;
+  options.attrs && Object.entries(options.attrs).forEach(([name, value]) => dom_js.setAttr(link, name, value));
+  link.href = options.href;
+  document.head.appendChild(link);
+}
+class SmartService {
+  constructor(_config) {
+    this._config = _config;
+    this._loaded = false;
+    this._mutex = Promise.resolve();
+  }
+  static config(options) {
+    if (options) this._config = __spreadValues$1(__spreadValues$1({}, this._config), options);
+    return this._config;
+  }
+  /** Create a new instance of SmartService */
+  static create(options) {
+    return new this(options);
+  }
+  /** Get the singleton instance of SmartService */
+  static get instance() {
+    if (!this._instance) {
+      this._instance = new this(this._config);
+    }
+    return this._instance;
+  }
+  /** Get the load method of the singleton instance */
+  static get load() {
+    return this.instance.load;
+  }
+  /** Setup Early Hints for the service */
+  static setupEarlyHints(options) {
+    return () => {
+      setTimeout(() => options.forEach(applyEarlyHints), 1);
+      return Promise.resolve();
+    };
+  }
+  /** Get the preload method of the singleton instance */
+  static get preload() {
+    return this.instance.preload;
+  }
+  /** Check if the service is loaded */
+  get isLoaded() {
+    return this._loaded;
+  }
+  /** Get the current mutex promise */
+  get mutex() {
+    return this._mutex;
+  }
+  /** Set a new mutex promise */
+  set mutex(value) {
+    this._debug("new Mutex: ", this._config.name, value);
+    this._mutex = value;
+  }
+  load() {
+    return __async$2(this, null, function* () {
+      this._debug("Service load() enter: ", this._config.name, this);
+      if (!this._state) {
+        this._state = this._loadTask();
+      }
+      return this._state;
+    });
+  }
+  preload() {
+    return __async$2(this, null, function* () {
+      this._debug("Service preload(): ", this._config.name);
+      const { url, attrs } = this._config;
+      if (url) setTimeout(applyEarlyHints.bind(null, { rel: "preload", href: url, attrs: __spreadValues$1({ as: "script" }, attrs) }), 1);
+      return Promise.resolve();
+    });
+  }
+  _loadTask() {
+    return __async$2(this, null, function* () {
+      try {
+        yield this._mutex;
+        this._debug("Service loading started: ", this._config.name);
+        if (!this._config.name) throw new Error("Service name is not specified");
+        if (!this._config.url) throw new Error("Service URL is not specified");
+        const id = (this._config.name || "").replace(/\s+/g, "").toLowerCase();
+        yield dom_js.loadScript(`smart-${id}-script`, this._config.url, this._config.attrs);
+        this._onLoadScript();
+        return true;
+      } catch (e) {
+        this._onFailedScript(e);
+        return Promise.reject(false);
+      }
+    });
+  }
+  _onLoadScript() {
+    this._debug("Service script loaded: ", this._config.name);
+    this._loaded = true;
+  }
+  _onFailedScript(e) {
+    console.error(`Failed to load ${this._config.name} script`, e instanceof Error ? `: ${e.message}` : "");
+  }
+  _debug(...args) {
+    if (!this._config.debug) return;
+    console.log(...args);
+  }
+}
+SmartService._config = {
+  name: "service",
+  debug: false
+};
+__decorateClass$1([
+  decorators_js.bind
+], SmartService.prototype, "load");
+__decorateClass$1([
+  decorators_js.bind
+], SmartService.prototype, "preload");
+
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = __getOwnPropDesc(target, key) ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp$1(target, key, result);
+  return result;
+};
+var __async$1 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function onReadyState(readyPredicate) {
+  return new Promise((resolve) => {
+    if (readyPredicate()) {
+      resolve();
+    } else {
+      const handler = () => {
+        if (readyPredicate()) {
+          document.removeEventListener("readystatechange", handler);
+          resolve();
+        }
+      };
+      document.addEventListener("readystatechange", handler);
+    }
+  });
+}
+class SmartLoad {
+  static defaultMutex() {
+    return this.createMutex(this.now);
+  }
+  static now() {
+    return Promise.resolve();
+  }
+  static onLoaded() {
+    return onReadyState(() => document.readyState !== "loading");
+  }
+  static onComplete() {
+    return onReadyState(() => document.readyState === "complete");
+  }
+  static createMutex(previousTask) {
+    return new Promise((resolve) => {
+      (() => __async$1(this, null, function* () {
+        try {
+          yield this._whenStarted.promise;
+          yield previousTask();
+        } catch (e) {
+        } finally {
+          resolve();
+        }
+      }))();
+    });
+  }
+  /** Queue a service to be loaded after the given task */
+  static queue(service, after = this.defaultMutex.bind(this)) {
+    const serviceInstance = service instanceof SmartService ? service : service.instance;
+    serviceInstance.mutex = this.createMutex(after);
+    serviceInstance.load().catch(() => void 0);
+  }
+  /** Start the smart loading process */
+  static start() {
+    this._whenStarted.resolve();
+  }
+}
+SmartLoad._whenStarted = async_js.createDeferred();
+__decorateClass([
+  decorators_js.memoize()
+], SmartLoad, "defaultMutex");
+__decorateClass([
+  decorators_js.memoize()
+], SmartLoad, "now");
+__decorateClass([
+  decorators_js.memoize()
+], SmartLoad, "onLoaded");
+__decorateClass([
+  decorators_js.memoize()
+], SmartLoad, "onComplete");
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const IDLE_THRESHOLD_DURATION = 46.6;
+const IDLE_THRESHOLD_RATIO = 0.9;
+const IDLE_TIMEOUT = 1e4;
+function promisifyIdle(options = {}) {
+  var _a, _b;
+  const idleThresholdRatio = ((_a = options.thresholds) == null ? void 0 : _a.ratio) || IDLE_THRESHOLD_RATIO;
+  const idleThresholdDuration = ((_b = options.thresholds) == null ? void 0 : _b.duration) || IDLE_THRESHOLD_DURATION;
+  const idleTimeout = options.timeout || IDLE_TIMEOUT;
+  const { debug, signal } = options;
+  debug && performance.mark("idle.S");
+  return new Promise((resolve, reject) => {
+    const start = performance.now();
+    let previousFrameEnd = start;
+    const log = [];
+    const last3 = [0, 0, 0];
+    function finish(withResolve, reason) {
+      if (debug) {
+        console.table(log);
+        console.log(`Idle has ${withResolve ? "reached" : "aborted"} after ${performance.now() - start}ms`);
+        performance.mark("idle.E");
+        performance.measure("idlePromisify", "idle.S", "idle.E");
+      }
+      return withResolve ? resolve(true) : reject(reason);
+    }
+    const cb = (deadline) => {
+      if (signal == null ? void 0 : signal.aborted) return finish(false, new Error("Rejected by abort signal"));
+      const allocated = deadline.timeRemaining();
+      const frameEnd = performance.now() + allocated;
+      const frameLength = frameEnd - previousFrameEnd;
+      const idleRatio = allocated / frameLength;
+      const timeout = Math.max(0, idleTimeout - (performance.now() - start));
+      const isBadFrame = frameLength < 15;
+      if (!isBadFrame) {
+        last3.splice(0, 1);
+        last3.push(idleRatio > idleThresholdRatio ? allocated : 0);
+      }
+      const isIdleNow = last3.reduce((acc, val) => acc + val, 0) > idleThresholdDuration;
+      debug && !isBadFrame && log.push([timeout, frameLength, allocated, idleRatio, idleRatio > idleThresholdRatio ? 1 : 0, last3.toString()]);
+      if (isIdleNow || deadline.didTimeout) return finish(true);
+      !isBadFrame && (previousFrameEnd = frameEnd);
+      requestIdleCallback(cb, { timeout });
+    };
+    requestIdleCallback(cb, { timeout: idleTimeout });
+  });
+}
+function asyncSeries(tasks) {
+  return __async(this, null, function* () {
+    for (const task of tasks) {
+      yield task().catch();
+    }
+  });
+}
+function waitAny(tasks, signal) {
+  return (abortSignal) => __async(null, null, function* () {
+    const activeSignal = signal != null ? signal : abortSignal;
+    if (activeSignal) {
+      yield Promise.race(tasks.map((task) => task(activeSignal)));
+      return;
+    }
+    const controller = new AbortController();
+    try {
+      yield Promise.race(tasks.map((task) => task(controller.signal)));
+    } finally {
+      controller.abort();
+    }
+  });
+}
+function waitTimeout(timeout) {
+  return () => __async(null, null, function* () {
+    return async_js.promisifyTimeout(timeout);
+  });
+}
+const USER_ACTIVITY_EVENTS = ["keydown", "mousemove", "pointerdown", "wheel"];
+function waitUserActivity() {
+  return (abortSignal) => __async(null, null, function* () {
+    yield waitAny(
+      USER_ACTIVITY_EVENTS.map((event) => (signal) => async_js.promisifyEvent(document, event, null, { passive: true, signal })),
+      abortSignal
+    )();
+  });
+}
+function waitIdle(options = {}) {
+  return (abortSignal) => __async(null, null, function* () {
+    return promisifyIdle(__spreadProps(__spreadValues({}, options), { signal: abortSignal }));
+  });
+}
+
+exports.SmartLoad = SmartLoad;
+exports.SmartService = SmartService;
+exports.asyncSeries = asyncSeries;
+exports.promisifyIdle = promisifyIdle;
+exports.waitAny = waitAny;
+exports.waitIdle = waitIdle;
+exports.waitTimeout = waitTimeout;
+exports.waitUserActivity = waitUserActivity;

package/dist/index.d.cts

@@ -0,0 +1,144 @@
+import * as _exadel_esl_modules_esl_utils_async from '@exadel/esl/modules/esl-utils/async';
+import { LoadScriptAttributes } from '@exadel/esl/modules/esl-utils/dom';
+
+/** Configuration options for SmartService */
+interface SmartServiceOptions {
+    /** Service name */
+    name?: string;
+    /** Service URL */
+    url?: string;
+    /** Attributes for the script element */
+    attrs?: LoadScriptAttributes;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/** Attributes for Early Hints link elements */
+interface EarlyHintsAttributes {
+    /** 'as' attribute value */
+    as?: string;
+    /** 'crossorigin' attribute value */
+    crossorigin?: string | boolean | null;
+}
+/** Options for Early Hints link elements */
+interface EarlyHintsOptions {
+    /** Link element relationship type */
+    rel: 'dns-prefetch' | 'preconnect' | 'prefetch' | 'preload' | 'prerender';
+    /** Link element href */
+    href: string;
+    /** Additional attributes for the link element */
+    attrs?: EarlyHintsAttributes;
+}
+/** Base class for smart services that load external scripts */
+declare class SmartService {
+    protected _config: SmartServiceOptions;
+    protected static _config: SmartServiceOptions;
+    protected static _instance: SmartService;
+    /** Get or set the service configuration */
+    static config<T>(options?: T): T;
+    /** Create a new instance of SmartService */
+    static create(options: SmartServiceOptions): SmartService;
+    /** Get the singleton instance of SmartService */
+    static get instance(): SmartService;
+    /** Get the load method of the singleton instance */
+    static get load(): () => Promise<boolean>;
+    /** Setup Early Hints for the service */
+    static setupEarlyHints(options: EarlyHintsOptions[]): () => Promise<void>;
+    /** Get the preload method of the singleton instance */
+    static get preload(): () => Promise<void>;
+    protected _loaded: boolean;
+    protected _mutex: Promise<void>;
+    protected _state: Promise<boolean>;
+    protected constructor(_config: SmartServiceOptions);
+    /** Check if the service is loaded */
+    get isLoaded(): boolean;
+    /** Get the current mutex promise */
+    get mutex(): Promise<void>;
+    /** Set a new mutex promise */
+    set mutex(value: Promise<void>);
+    /** Load the service script */
+    load(): Promise<boolean>;
+    /** Preload the service script using Early Hints */
+    preload(): Promise<void>;
+    protected _loadTask(): Promise<boolean>;
+    protected _onLoadScript(): void;
+    protected _onFailedScript(e?: Error): void;
+    protected _debug(...args: unknown[]): void;
+}
+
+/** Manager for smart loading of services */
+declare class SmartLoad {
+    protected static _whenStarted: _exadel_esl_modules_esl_utils_async.Deferred<void>;
+    /** Get the default mutex promise which resolves immediately */
+    static defaultMutex(): Promise<void>;
+    /** No wait and resolve immediately */
+    static now(): Promise<void>;
+    /** Wait until the document is at least interactive and then resolve */
+    static onLoaded(): Promise<void>;
+    /** Wait until the document is fully loaded and then resolve */
+    static onComplete(): Promise<void>;
+    protected static createMutex(previousTask: () => Promise<unknown>): Promise<void>;
+    /** Queue a service to be loaded after the given task */
+    static queue(service: typeof SmartService | SmartService, after?: () => Promise<unknown>): void;
+    /** Start the smart loading process */
+    static start(): void;
+}
+
+type AsyncTask = () => Promise<unknown>;
+type WaitTask = (signal?: AbortSignal) => Promise<unknown>;
+/** Options for promisifyIdle function */
+interface PromisifyIdleOptions {
+    /** Thresholds to determine idle state */
+    thresholds?: {
+        /** Total idle time threshold in ms */
+        duration?: number;
+        /** Idle time to frame time ratio threshold */
+        ratio?: number;
+    };
+    /** Maximum timeout in ms */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** AbortSignal to cancel the idle detection */
+    signal?: AbortSignal;
+}
+/** Promisify requestIdleCallback with enhanced idle detection
+ * The promise resolves when the browser is considered idle based on:
+ * - ratio of idle time to frame time over a series of frames
+ * - total idle time accumulated over a series of frames
+ * - maximum timeout
+ *
+ * @param options - Configuration options for idle detection
+ * @returns Promise that resolves when idle state is reached or rejects on abort
+ */
+declare function promisifyIdle(options?: PromisifyIdleOptions): Promise<any>;
+/** Executes asynchronous tasks in series
+ * Each task starts after the previous one has completed.
+ *
+ * @param tasks - Array of asynchronous tasks to execute
+ * @returns Promise that resolves when all tasks have completed
+ */
+declare function asyncSeries(tasks: AsyncTask[]): Promise<void>;
+/** Executes multiple wait tasks in parallel
+ * Resolves when any of the tasks completes.
+ *
+ * @param tasks - Array of wait tasks to execute
+ * @param signal - Optional AbortSignal to cancel the wait
+ * @returns A wait task that resolves when any of the input tasks completes
+ */
+declare function waitAny(tasks: WaitTask[], signal?: AbortSignal): WaitTask;
+/** Creates a wait task that resolves after a specified timeout
+ *
+ * @param timeout - The timeout duration in milliseconds
+ * @returns A wait task that resolves after the specified timeout
+ */
+declare function waitTimeout(timeout: number): WaitTask;
+declare function waitUserActivity(): WaitTask;
+/** Creates a wait task that resolves when the browser is idle
+ *
+ * @param options - Configuration options for idle detection
+ * @returns A wait task that resolves when the browser is idle
+ */
+declare function waitIdle(options?: PromisifyIdleOptions): WaitTask;
+
+export { SmartLoad, SmartService, asyncSeries, promisifyIdle, waitAny, waitIdle, waitTimeout, waitUserActivity };
+export type { EarlyHintsAttributes, EarlyHintsOptions, PromisifyIdleOptions, SmartServiceOptions };

package/dist/index.d.mts

@@ -0,0 +1,144 @@
+import * as _exadel_esl_modules_esl_utils_async from '@exadel/esl/modules/esl-utils/async';
+import { LoadScriptAttributes } from '@exadel/esl/modules/esl-utils/dom';
+
+/** Configuration options for SmartService */
+interface SmartServiceOptions {
+    /** Service name */
+    name?: string;
+    /** Service URL */
+    url?: string;
+    /** Attributes for the script element */
+    attrs?: LoadScriptAttributes;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/** Attributes for Early Hints link elements */
+interface EarlyHintsAttributes {
+    /** 'as' attribute value */
+    as?: string;
+    /** 'crossorigin' attribute value */
+    crossorigin?: string | boolean | null;
+}
+/** Options for Early Hints link elements */
+interface EarlyHintsOptions {
+    /** Link element relationship type */
+    rel: 'dns-prefetch' | 'preconnect' | 'prefetch' | 'preload' | 'prerender';
+    /** Link element href */
+    href: string;
+    /** Additional attributes for the link element */
+    attrs?: EarlyHintsAttributes;
+}
+/** Base class for smart services that load external scripts */
+declare class SmartService {
+    protected _config: SmartServiceOptions;
+    protected static _config: SmartServiceOptions;
+    protected static _instance: SmartService;
+    /** Get or set the service configuration */
+    static config<T>(options?: T): T;
+    /** Create a new instance of SmartService */
+    static create(options: SmartServiceOptions): SmartService;
+    /** Get the singleton instance of SmartService */
+    static get instance(): SmartService;
+    /** Get the load method of the singleton instance */
+    static get load(): () => Promise<boolean>;
+    /** Setup Early Hints for the service */
+    static setupEarlyHints(options: EarlyHintsOptions[]): () => Promise<void>;
+    /** Get the preload method of the singleton instance */
+    static get preload(): () => Promise<void>;
+    protected _loaded: boolean;
+    protected _mutex: Promise<void>;
+    protected _state: Promise<boolean>;
+    protected constructor(_config: SmartServiceOptions);
+    /** Check if the service is loaded */
+    get isLoaded(): boolean;
+    /** Get the current mutex promise */
+    get mutex(): Promise<void>;
+    /** Set a new mutex promise */
+    set mutex(value: Promise<void>);
+    /** Load the service script */
+    load(): Promise<boolean>;
+    /** Preload the service script using Early Hints */
+    preload(): Promise<void>;
+    protected _loadTask(): Promise<boolean>;
+    protected _onLoadScript(): void;
+    protected _onFailedScript(e?: Error): void;
+    protected _debug(...args: unknown[]): void;
+}
+
+/** Manager for smart loading of services */
+declare class SmartLoad {
+    protected static _whenStarted: _exadel_esl_modules_esl_utils_async.Deferred<void>;
+    /** Get the default mutex promise which resolves immediately */
+    static defaultMutex(): Promise<void>;
+    /** No wait and resolve immediately */
+    static now(): Promise<void>;
+    /** Wait until the document is at least interactive and then resolve */
+    static onLoaded(): Promise<void>;
+    /** Wait until the document is fully loaded and then resolve */
+    static onComplete(): Promise<void>;
+    protected static createMutex(previousTask: () => Promise<unknown>): Promise<void>;
+    /** Queue a service to be loaded after the given task */
+    static queue(service: typeof SmartService | SmartService, after?: () => Promise<unknown>): void;
+    /** Start the smart loading process */
+    static start(): void;
+}
+
+type AsyncTask = () => Promise<unknown>;
+type WaitTask = (signal?: AbortSignal) => Promise<unknown>;
+/** Options for promisifyIdle function */
+interface PromisifyIdleOptions {
+    /** Thresholds to determine idle state */
+    thresholds?: {
+        /** Total idle time threshold in ms */
+        duration?: number;
+        /** Idle time to frame time ratio threshold */
+        ratio?: number;
+    };
+    /** Maximum timeout in ms */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** AbortSignal to cancel the idle detection */
+    signal?: AbortSignal;
+}
+/** Promisify requestIdleCallback with enhanced idle detection
+ * The promise resolves when the browser is considered idle based on:
+ * - ratio of idle time to frame time over a series of frames
+ * - total idle time accumulated over a series of frames
+ * - maximum timeout
+ *
+ * @param options - Configuration options for idle detection
+ * @returns Promise that resolves when idle state is reached or rejects on abort
+ */
+declare function promisifyIdle(options?: PromisifyIdleOptions): Promise<any>;
+/** Executes asynchronous tasks in series
+ * Each task starts after the previous one has completed.
+ *
+ * @param tasks - Array of asynchronous tasks to execute
+ * @returns Promise that resolves when all tasks have completed
+ */
+declare function asyncSeries(tasks: AsyncTask[]): Promise<void>;
+/** Executes multiple wait tasks in parallel
+ * Resolves when any of the tasks completes.
+ *
+ * @param tasks - Array of wait tasks to execute
+ * @param signal - Optional AbortSignal to cancel the wait
+ * @returns A wait task that resolves when any of the input tasks completes
+ */
+declare function waitAny(tasks: WaitTask[], signal?: AbortSignal): WaitTask;
+/** Creates a wait task that resolves after a specified timeout
+ *
+ * @param timeout - The timeout duration in milliseconds
+ * @returns A wait task that resolves after the specified timeout
+ */
+declare function waitTimeout(timeout: number): WaitTask;
+declare function waitUserActivity(): WaitTask;
+/** Creates a wait task that resolves when the browser is idle
+ *
+ * @param options - Configuration options for idle detection
+ * @returns A wait task that resolves when the browser is idle
+ */
+declare function waitIdle(options?: PromisifyIdleOptions): WaitTask;
+
+export { SmartLoad, SmartService, asyncSeries, promisifyIdle, waitAny, waitIdle, waitTimeout, waitUserActivity };
+export type { EarlyHintsAttributes, EarlyHintsOptions, PromisifyIdleOptions, SmartServiceOptions };