build

packages/overlayscrollbars/types/lifecycles/lifecycleHubObservers.d.ts

@@ -0,0 +1,6 @@
+import { LifecycleHub, LifecycleCheckOption, LifecycleUpdateHints } from 'lifecycles/lifecycleHub';
+export declare const lifecycleHubOservers: (instance: LifecycleHub, updateLifecycles: (updateHints?: Partial<LifecycleUpdateHints> | null | undefined) => unknown) => {
+    _trinsicObserver: false | import("observers/trinsicObserver").TrinsicObserver;
+    _sizeObserver: import("observers/sizeObserver").SizeObserver;
+    _updateObserverOptions: (checkOption: LifecycleCheckOption) => void;
+};

packages/overlayscrollbars/types/observers/domObserver.d.ts

@@ -1,5 +1,5 @@
 declare type StringNullUndefined = string | null | undefined;
-declare type DOMContentObserverCallback = (contentChanged: boolean) => any;
+declare type DOMContentObserverCallback = (contentChangedTroughEvent: boolean) => any;
 declare type DOMTargetObserverCallback = (targetChangedAttrs: string[], targetStyleChanged: boolean) => any;
 interface DOMObserverOptionsBase {
     _attributes?: string[];
@@ -14,22 +14,16 @@ interface DOMContentObserverOptions extends DOMObserverOptionsBase {
 interface DOMTargetObserverOptions extends DOMObserverOptionsBase {
     _ignoreTargetChange?: DOMObserverIgnoreTargetChange;
 }
-interface DOMObserverBase {
-    _destroy: () => void;
-    _update: () => void;
-}
-interface DOMContentObserver extends DOMObserverBase {
-    _updateEventContentChange: (newEventContentChange?: DOMObserverEventContentChange) => void;
-}
-interface DOMTargetObserver extends DOMObserverBase {
-}
-declare type ContentChangeArrayItem = [StringNullUndefined, ((elms: Node[]) => StringNullUndefined) | StringNullUndefined] | null | undefined;
+declare type ContentChangeArrayItem = [StringNullUndefined, StringNullUndefined] | null | undefined;
 export declare type DOMObserverEventContentChange = Array<ContentChangeArrayItem> | false | null | undefined;
-export declare type DOMObserverIgnoreContentChange = (mutation: MutationRecord, isNestedTarget: boolean, domObserverTarget: HTMLElement, domObserverOptions: DOMContentObserverOptions | undefined) => boolean;
+export declare type DOMObserverIgnoreContentChange = (mutation: MutationRecord, isNestedTarget: boolean, domObserverTarget: HTMLElement, domObserverOptions?: DOMContentObserverOptions) => boolean;
 export declare type DOMObserverIgnoreTargetChange = (target: Node, attributeName: string, oldAttributeValue: string | null, newAttributeValue: string | null) => boolean;
 export declare type DOMObserverCallback<ContentObserver extends boolean> = ContentObserver extends true ? DOMContentObserverCallback : DOMTargetObserverCallback;
 export declare type DOMObserverOptions<ContentObserver extends boolean> = ContentObserver extends true ? DOMContentObserverOptions : DOMTargetObserverOptions;
-export declare type DOMObserver<ContentObserver extends boolean> = ContentObserver extends true ? DOMContentObserver : DOMTargetObserver;
+export interface DOMObserver {
+    _destroy: () => void;
+    _update: () => void;
+}
 /**
  * Creates a DOM observer which observes DOM changes to either the target element or its children.
  * @param target The element which shall be observed.
@@ -38,5 +32,5 @@ export declare type DOMObserver<ContentObserver extends boolean> = ContentObserv
  * @param options The options for DOM change detection.
  * @returns A object which represents the instance of the DOM observer.
  */
-export declare const createDOMObserver: <ContentObserver extends boolean>(target: HTMLElement, isContentObserver: ContentObserver, callback: DOMObserverCallback<ContentObserver>, options?: DOMObserverOptions<ContentObserver> | undefined) => DOMObserver<ContentObserver>;
+export declare const createDOMObserver: <ContentObserver extends boolean>(target: HTMLElement, isContentObserver: ContentObserver, callback: DOMObserverCallback<ContentObserver>, options?: DOMObserverOptions<ContentObserver> | undefined) => DOMObserver;
 export {};

packages/overlayscrollbars/types/observers/sizeObserver.d.ts

@@ -1,8 +1,13 @@
 import { CacheValues } from 'support';
-export declare type SizeObserverOptions = {
+export interface SizeObserverOptions {
     _direction?: boolean;
     _appear?: boolean;
-};
+}
+export interface SizeObserverCallbackParams {
+    _sizeChanged: boolean;
+    _directionIsRTLCache?: CacheValues<boolean>;
+    _appear?: boolean;
+}
 export interface SizeObserver {
     _destroy(): void;
     _getCurrentCacheValues(force?: boolean): {
@@ -16,4 +21,4 @@ export interface SizeObserver {
  * @param options The options for size detection, whether to observe also direction and appear.
  * @returns A object which represents the instance of the size observer.
  */
-export declare const createSizeObserver: (target: HTMLElement, onSizeChangedCallback: (directionIsRTLCache?: CacheValues<boolean> | undefined) => any, options?: SizeObserverOptions | undefined) => SizeObserver;
+export declare const createSizeObserver: (target: HTMLElement, onSizeChangedCallback: (params: SizeObserverCallbackParams) => any, options?: SizeObserverOptions | undefined) => SizeObserver;

packages/overlayscrollbars/types/options.d.ts

@@ -15,9 +15,8 @@ export interface OSOptions {
     paddingAbsolute: boolean;
     updating: {
         elementEvents: Array<[string, string]> | null;
-        contentMutationDebounce: number;
-        hostMutationDebounce: number;
-        resizeDebounce: number;
+        attributes: string[] | null;
+        debounce: number | [number, number] | null;
     };
     overflow: {
         x: OverflowBehavior;

packages/overlayscrollbars/types/support/utils/function.d.ts

@@ -1,8 +1,28 @@
+declare type DebounceTiming = number | false | null | undefined;
+export interface DebounceOptions<FunctionToDebounce extends (...args: any) => any> {
+    /**
+     * The timeout for debouncing. If null, no debounce is applied.
+     */
+    _timeout?: DebounceTiming | (() => DebounceTiming);
+    /**
+     * A maximum amount of ms. before the function will be called even with debounce.
+     */
+    _maxDelay?: DebounceTiming | (() => DebounceTiming);
+    /**
+     * Function which merges parameters for each canceled debounce.
+     * If parameters can't be merged the function will return null, otherwise it returns the merged parameters.
+     */
+    _mergeParams?: (prev: Parameters<FunctionToDebounce>, curr: Parameters<FunctionToDebounce>) => Parameters<FunctionToDebounce> | false | null | undefined;
+}
+export interface Debounced<FunctionToDebounce extends (...args: any) => any> {
+    (...args: Parameters<FunctionToDebounce>): ReturnType<FunctionToDebounce>;
+    _flush(): void;
+}
 export declare const noop: () => void;
 /**
  * Debounces the given function either with a timeout or a animation frame.
  * @param functionToDebounce The function which shall be debounced.
- * @param timeout The timeout for debouncing. If 0 or lower animation frame is used for debouncing, a timeout otherwise.
- * @param maxWait A maximum amount of ms. before the function will be called even with debounce.
+ * @param options Options for debouncing.
  */
-export declare const debounce: (functionToDebounce: (...args: any) => any, timeout?: number | undefined, maxWait?: number | undefined) => () => void;
+export declare const debounce: <FunctionToDebounce extends (...args: any) => any>(functionToDebounce: FunctionToDebounce, options: DebounceOptions<FunctionToDebounce>) => Debounced<FunctionToDebounce>;
+export {};