ngx-kit 7.2.0 → 7.3.0

package/types/ngx-kit-dialog.d.ts

@@ -1,140 +1,241 @@
-import * as i0 from '@angular/core';
-import { Injector, ElementRef, OnInit, AfterViewInit, OnDestroy, Type, ComponentRef, ApplicationRef, EnvironmentInjector, Renderer2, InjectionToken } from '@angular/core';
-import * as rxjs from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, Injector, EnvironmentProviders, Type, InjectionToken } from '@angular/core';
+import * as ngx_kit_dialog from 'ngx-kit/dialog';
 import { Observable } from 'rxjs';
-import * as i5 from '@angular/common';
+import { OverlayRef } from 'ngx-kit/core';
+import * as i1 from 'ngx-kit/drag-resize';
 
+type NgxDialogFooterAlign = 'start' | 'end' | 'center' | 'space-between' | 'space-around';
+declare class NgxDialogFooter implements OnInit, OnDestroy {
+    readonly align: _angular_core.InputSignal<NgxDialogFooterAlign>;
+    private readonly el;
+    private readonly dialogRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxDialogFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxDialogFooter, "ngx-dialog-footer,[ngxDialogFooter]", ["ngxDialogFooter"], { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NgxDialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+interface NgxDialogHeaderConfig {
+    enable?: boolean;
+    title?: string;
+    showCloseButton?: boolean;
+    showMaximizeButton?: boolean;
+}
+interface NgxDialogFooterConfig {
+    enable?: boolean;
+    /** Text for the auto-generated close button. Default: 'Close'. */
+    closeText?: string;
+    align?: NgxDialogFooterAlign;
+}
+/**
+ * BREAKING CHANGE from the previous version of this config:
+ * - `allowCloseOnOutsideClick` -> `closeOnOutsideClick` (naming now matches
+ *   `ngx-kit/overlay`'s options, which this service is built directly on).
+ * - `header`/`footer` are now actually wired up (previously declared but
+ *   unused) - set `enable: true` to get an automatic header/footer without
+ *   having to place the `ngxDialogHeader`/`ngxDialogFooter` directives
+ *   yourself inside the content component.
+ */
 declare class NgxDialogConfig<DataType = any> {
-    /**
-     * pass data to dialog
-     */
-    data?: DataType | any;
-    /** close dialog on outside click
-     * - default false */
-    allowCloseOnOutsideClick?: boolean;
-    /**
-     * container class
-     * - You can separate the list of classes with a space
-     * - for example:"`my class one two three ...`"
-     *
-     * TODO: must set with public config setter
-     */
-    containerClass?: string | undefined;
-    header?: {
-        enable?: true;
-        title?: '';
-        showCloseButton?: true;
-    };
-    footer?: {
-        enable?: true;
-    };
+    /** Data made available to the content component (and to `ngx-dialog-panel`
+     * itself) via the `DIALOG_DATA` injection token. */
+    data?: DataType;
+    /** Named size preset - sets sensible min/max width bounds. Combine with
+     * `width`/`maxWidth`/... for full manual control. */
+    size?: NgxDialogSize;
     width?: string;
     minWidth?: string;
     maxWidth?: string;
     height?: string;
     minHeight?: string;
     maxHeight?: string;
-    /** parent injector */
+    /** Extra class(es) on the dialog panel (the `ngx-dialog-panel` host). */
+    panelClass?: string | string[];
+    /** Extra class(es) on the backdrop element behind the panel. */
+    backdropClass?: string | string[];
+    header?: NgxDialogHeaderConfig;
+    footer?: NgxDialogFooterConfig;
+    /** Close when clicking outside the panel. Default: false (modal by default). */
+    closeOnOutsideClick?: boolean;
+    /** Close on Escape. Default: true. */
+    closeOnEscape?: boolean;
+    /** Shorthand for `closeOnOutsideClick: false, closeOnEscape: false` - the
+     * dialog can then only be closed programmatically (e.g. via its own
+     * buttons calling `dialogRef.close()`). */
+    disableClose?: boolean;
+    /** Synchronous guard consulted before Escape/outside-click would close the
+     * dialog - return `false` to block it (e.g. unsaved changes). Does not
+     * affect a programmatic `dialogRef.close()` call. */
+    beforeClose?: () => boolean;
+    /** Prevent the page behind the dialog from scrolling while it's open. Default: true. */
+    lockBodyScroll?: boolean;
+    /** Move focus into the dialog on open. Default: true. */
+    autoFocus?: boolean;
+    /** Restore focus to the previously focused element on close. Default: true. */
+    restoreFocus?: boolean;
+    /** Render via the native Popover API when supported. Default: true. */
+    usePopover?: boolean;
+    role?: 'dialog' | 'alertdialog';
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+    /** Entry animation for the panel. Default: 'zoom'. */
+    animation?: 'zoom' | 'fade' | 'slide-up' | 'none';
+    /** Parent injector for the content component (and `ngx-dialog-panel`
+     * itself). Defaults to the root injector. */
     injector?: Injector;
-    constructor();
+    constructor(init?: Partial<NgxDialogConfig<DataType>>);
 }
 
-declare class NgxDialogRef {
-    dialog?: ElementRef<HTMLElement>;
-    header?: ElementRef<HTMLElement>;
-    footer?: ElementRef<HTMLElement>;
-    body?: ElementRef<HTMLElement>;
+declare function provideNgxDialog(config?: NgxDialogConfig): EnvironmentProviders;
+
+declare class NgxDialogRef<R = any> {
+    readonly id: string;
+    /** true from the moment `close()` is called, even before teardown finishes. */
+    readonly closing: _angular_core.WritableSignal<boolean>;
+    /** true once the dialog has been fully removed from the DOM. */
+    readonly closed: _angular_core.WritableSignal<boolean>;
     private readonly _afterClosed;
-    afterClosed: Observable<any>;
-    id?: string;
-    close(result?: any): void;
+    /** Emits the result exactly once, after the dialog has been fully torn down. */
+    readonly afterClosed: Observable<R | undefined>;
+    /** @internal set by the layout directives; read by NgxDialogBody to size itself. */
+    readonly headerEl: _angular_core.WritableSignal<HTMLElement | null>;
+    /** @internal */
+    readonly footerEl: _angular_core.WritableSignal<HTMLElement | null>;
+    /** @internal */
+    readonly bodyEl: _angular_core.WritableSignal<HTMLElement | null>;
+    /** @internal the dialog panel's own host element. */
+    readonly panelEl: _angular_core.WritableSignal<HTMLElement | null>;
+    /** Optional synchronous guard - return `false` to prevent Escape/outside-click from closing. */
+    beforeClose?: () => boolean;
+    private overlayRef?;
+    private result;
+    /** @internal used by NgxDialogService right after creating the overlay. */
+    _attachOverlayRef(ref: OverlayRef<unknown>): void;
+    /** @internal used by the header/footer/body directives and the panel component. */
+    _setHeaderElement(el: HTMLElement | null): void;
+    /** @internal */
+    _setFooterElement(el: HTMLElement | null): void;
+    /** @internal */
+    _setBodyElement(el: HTMLElement | null): void;
+    /** @internal */
+    _setPanelElement(el: HTMLElement | null): void;
+    /** Closes the dialog and emits `result` on `afterClosed` once torn down. Idempotent. */
+    close(result?: R): void;
+    /** @internal called by NgxDialogService's `onClosed` callback once the overlay is fully torn down. */
+    _finalizeClose(): void;
 }
 
-declare class NgxDialogComponent implements OnInit, AfterViewInit, OnDestroy {
-    config?: NgxDialogConfig;
-    component: Type<any>;
-    private readonly _onClose;
-    onClose: rxjs.Observable<void>;
-    ngxDialog?: ElementRef<HTMLElement>;
-    _dialogRef: NgxDialogRef;
-    private cd;
+/**
+ * The dialog "panel" shell. It no longer owns the backdrop, centering,
+ * focus trap, Escape handling or outside-click handling - all of that now
+ * lives in `OverlayService`, which this component is rendered inside of.
+ * This is intentionally a thin, fully signal-driven shell: no
+ * `AfterViewInit`, no manual `ChangeDetectorRef.detectChanges()`, no
+ * imperative style writes. Angular schedules change detection automatically
+ * whenever a signal read from the template changes, including in zoneless
+ * apps.
+ */
+declare class NgxDialogComponent {
+    protected readonly dialogRef: NgxDialogRef<any>;
+    protected readonly config: ngx_kit_dialog.NgxDialogConfig<any>;
+    protected readonly content: _angular_core.Type<any>;
+    protected readonly sizeClass: _angular_core.Signal<string>;
     constructor();
-    ngOnInit(): void;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    onOverlayClicked(evt: MouseEvent): void;
-    onDialogClicked(evt: MouseEvent): void;
-    close(): void;
-    setStyle(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDialogComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgxDialogComponent, "ng-component", never, {}, {}, never, never, false, never>;
-}
-
-declare class NgxOverlayService {
-    private appRef;
-    private injector;
-    private envInjector;
-    dialogComponentRefs: ComponentRef<NgxDialogComponent>[];
-    _defaultOptions: NgxDialogConfig | undefined;
-    constructor(appRef: ApplicationRef, injector: Injector, envInjector: EnvironmentInjector);
-    open(component: Type<any>, config?: NgxDialogConfig): NgxDialogRef;
-    private _open;
-    private removeDialogComponentFromBody;
-    private appendDialogComponentToBody;
-    closeAll(): void;
-    private get getDialogId();
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxOverlayService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NgxOverlayService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxDialogComponent, "ngx-dialog-panel", never, {}, {}, never, never, true, never>;
 }
 
-declare class NgxDialogHeaderDirective implements OnInit {
-    _el: ElementRef<HTMLElement>;
-    private _document;
-    showCloseButton: boolean;
-    private _dialogRef;
-    constructor(_el: ElementRef<HTMLElement>, _document: Document);
+declare class NgxDialogHeader implements OnInit {
+    private config;
+    readonly showCloseButton: _angular_core.InputSignal<boolean>;
+    readonly showMaximizeButton: _angular_core.InputSignal<boolean>;
+    private readonly el;
+    private readonly document;
+    private readonly dialogRef;
+    private readonly drag;
+    private isMaximized;
     ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDialogHeaderDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDialogHeaderDirective, "ngx-dialog-header,[ngxDialogHeader]", ["ngxDialogHeader"], { "showCloseButton": { "alias": "showCloseButton"; "required": false; }; }, {}, never, never, false, never>;
+    private fullScreen;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxDialogHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxDialogHeader, "ngx-dialog-header,[ngxDialogHeader]", ["ngxDialogHeader"], { "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; "showMaximizeButton": { "alias": "showMaximizeButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgxDraggable; inputs: {}; outputs: {}; }]>;
 }
 
-declare class NgxDialogFooterDirective implements OnInit {
-    _el: ElementRef<HTMLElement>;
-    align: 'start' | 'end' | 'space-between' | 'center' | 'space-around';
-    private _dialogRef;
-    constructor(_el: ElementRef<HTMLElement>);
-    ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDialogFooterDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDialogFooterDirective, "ngx-dialog-footer,[ngxDialogFooter]", ["ngxDialogFooter"], { "align": { "alias": "align"; "required": false; }; }, {}, never, never, false, never>;
+/**
+ * Why this can't be pure CSS flexbox: the header/body/footer elements are
+ * *grandchildren* of the dialog panel (panel -> `*ngComponentOutlet`'s host
+ * element -> header/body/footer), not direct children, because the content
+ * component that hosts them is arbitrary and we don't control its own host
+ * styling. `display:flex;flex-direction:column` on the panel therefore can't
+ * size the body against the header/footer through that extra layer, so we
+ * measure and set an explicit `max-height` instead, driven by a
+ * `ResizeObserver` on the panel (not a `window:resize` listener, so it also
+ * reacts to the dialog itself changing size, e.g. via `config.size`).
+ */
+declare class NgxDialogBody {
+    private readonly el;
+    private readonly renderer;
+    private readonly dialogRef;
+    private readonly destroyRef;
+    constructor();
+    private recomputeHeight;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxDialogBody, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxDialogBody, "ngx-dialog-body,[ngxDialogBody]", ["ngxDialogBody"], {}, {}, never, never, true, never>;
 }
 
-declare class NgxDialogBodyDirective implements AfterViewInit {
-    _el: ElementRef<HTMLElement>;
-    private _renderer;
-    height?: number;
-    private _dialogRef;
-    constructor(_el: ElementRef<HTMLElement>, _renderer: Renderer2);
-    ngAfterViewInit(): void;
-    onWindowResize(ev?: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDialogBodyDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDialogBodyDirective, "ngx-dialog-body,[ngxDialogBody]", ["ngxDialogBody"], {}, {}, never, never, false, never>;
+declare class NgxDialogModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxDialogModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<NgxDialogModule, never, [typeof NgxDialogComponent, typeof NgxDialogHeader, typeof NgxDialogFooter, typeof NgxDialogBody], [typeof NgxDialogComponent, typeof NgxDialogHeader, typeof NgxDialogFooter, typeof NgxDialogBody]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<NgxDialogModule>;
 }
 
-declare class NgxDialogModule {
-    private readonly platformId;
-    constructor(parentModule: NgxDialogModule | null, service: NgxOverlayService);
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDialogModule, [{ optional: true; skipSelf: true; }, null]>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxDialogModule, [typeof NgxDialogComponent, typeof NgxDialogHeaderDirective, typeof NgxDialogFooterDirective, typeof NgxDialogBodyDirective], [typeof i5.CommonModule], [typeof NgxDialogComponent, typeof NgxDialogHeaderDirective, typeof NgxDialogFooterDirective, typeof NgxDialogBodyDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<NgxDialogModule>;
+declare class NgxDialogService {
+    private readonly overlay;
+    private readonly injector;
+    private readonly _openRefs;
+    /** Every currently open dialog, oldest first. */
+    readonly openDialogs: _angular_core.Signal<NgxDialogRef<any>[]>;
+    /** How many dialogs are currently open. */
+    readonly openCount: _angular_core.Signal<number>;
+    readonly defaultConfig: NgxDialogConfig<any>;
+    /**
+     * Opens `content` inside a dialog panel and returns a ref you can use to
+     * close it and read the result back (`afterClosed`).
+     */
+    open<R = any, DataType = any>(content: Type<any>, config?: Partial<NgxDialogConfig<DataType>>): NgxDialogRef<R>;
+    /** Closes every currently open dialog (ignores `disableClose`/guards - use sparingly, e.g. on logout). */
+    closeAll(): void;
+    private applySizing;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxDialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgxDialogService>;
 }
 
+/**
+ * Static convenience API over `NgxDialogService`, so you can call
+ * `Dialog.open(...)` from anywhere without injecting the service manually.
+ *
+ * SSR note: the instance backing this static class is process-wide, not
+ * per-request, so it is deliberately left unset on the server (see
+ * `provideNgxDialog()`). Inject `NgxDialogService` directly in SSR code paths.
+ */
 declare class Dialog {
     private static serviceInstance;
-    static _setService(svc: NgxOverlayService): void;
-    static open<DataType>(component: Type<any>, config?: NgxDialogConfig<DataType>): NgxDialogRef;
+    /** @internal set by `provideNgxDialog()`'s environment initializer. */
+    static _setService(svc: NgxDialogService): void;
+    private static get service();
+    static open<R = any, DataType = any>(component: Type<any>, config?: Partial<NgxDialogConfig<DataType>>): NgxDialogRef<R>;
+    static closeAll(): void;
 }
 
 declare const DIALOG_DATA: InjectionToken<any>;
-declare const DIALOG_REF: InjectionToken<NgxDialogRef>;
+declare const DIALOG_REF: InjectionToken<NgxDialogRef<any>>;
+/** The resolved config for the dialog currently being rendered. */
+declare const NGX_DIALOG_DEFAULT_CONFIG: NgxDialogConfig<any>;
+declare const NGX_DIALOG_CONFIG: InjectionToken<NgxDialogConfig<any>>;
+/** The arbitrary content component passed to `open()`, projected via `*ngComponentOutlet`. */
+declare const DIALOG_CONTENT: InjectionToken<Type<any>>;
 
-export { DIALOG_DATA, DIALOG_REF, Dialog, NgxDialogBodyDirective, NgxDialogComponent, NgxDialogConfig, NgxDialogFooterDirective, NgxDialogHeaderDirective, NgxDialogModule };
+export { DIALOG_CONTENT, DIALOG_DATA, DIALOG_REF, Dialog, NGX_DIALOG_CONFIG, NGX_DIALOG_DEFAULT_CONFIG, NgxDialogBody, NgxDialogComponent, NgxDialogConfig, NgxDialogFooter, NgxDialogHeader, NgxDialogModule, NgxDialogService, provideNgxDialog };
+export type { NgxDialogFooterAlign, NgxDialogFooterConfig, NgxDialogHeaderConfig, NgxDialogSize };

package/types/ngx-kit-drag-resize.d.ts

@@ -90,6 +90,7 @@ declare class DragRef<T = unknown> {
     private previousZIndex;
     private moveDx;
     private moveDy;
+    private scrollCompensation;
     private preview?;
     private previewOffsetX;
     private previewOffsetY;
@@ -110,6 +111,12 @@ declare class DragRef<T = unknown> {
     get pointer(): IPosition;
     get start(): DOMRect;
     getPlaceholderElement(): HTMLElement | undefined;
+    /**
+     * صدا زده می‌شود هر بار که container یا window در حین درگ اسکرول شود
+     * (چه توسط auto-scroll خودمان، چه با wheel/اسکرول‌بار دستی کاربر).
+     * transform را فوراً تصحیح می‌کند تا عنصر زیر پوینتر بماند.
+     */
+    notifyScroll(dx: number, dy: number): void;
     private applyTransform;
     private updatePreview;
 }
@@ -167,9 +174,9 @@ declare class NgxDraggable<T = unknown> implements OnInit, OnDestroy {
     readonly disabled: _angular_core.ModelSignal<boolean>;
     /** Element whose rect constrains the drag. Now actually enforced. */
     readonly boundary: _angular_core.InputSignal<HTMLElement | undefined>;
-    readonly dragRootElement: _angular_core.InputSignal<string>;
+    readonly dragRootElement: _angular_core.ModelSignal<string>;
     /** CSS selector for a drag handle. When set, only pointerdowns inside it start a drag. */
-    readonly dragHandle: _angular_core.InputSignal<string>;
+    readonly dragHandle: _angular_core.ModelSignal<string>;
     /** Restrict movement to a single axis. */
     readonly lockAxis: _angular_core.InputSignal<DragAxis>;
     /** Minimum pointer travel (px) before a drag starts, so clicks still register normally. */
@@ -192,15 +199,27 @@ declare class NgxDraggable<T = unknown> implements OnInit, OnDestroy {
     private down;
     private start;
     private pointerId;
+    private lastPointer;
     private removeDown?;
     private removeMove?;
     private removeUp?;
     private removeKeydown?;
     private removeEscape?;
+    private scrollTarget;
+    private lastScroll;
+    private lastWindowScroll;
+    private removeContainerScroll?;
+    private removeWindowScroll?;
     constructor(host: ElementRef<HTMLElement>, renderer: Renderer2);
     ngOnInit(): void;
     ngOnDestroy(): void;
     private pointerDown;
+    private applyDragUpdate;
+    /** فراخوانی می‌شود دقیقاً وقتی drag واقعاً شروع می‌شود (چه با موس، چه با کیبورد). */
+    private startScrollTracking;
+    private handleContainerScroll;
+    private handleWindowScroll;
+    private stopScrollTracking;
     private pointerMove;
     private pointerUp;
     private cancel;
@@ -210,7 +229,7 @@ declare class NgxDraggable<T = unknown> implements OnInit, OnDestroy {
     private isOnHandle;
     private isInteractive;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxDraggable<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxDraggable<any>, "[NgxDraggable],[ngxDraggable]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "boundary": { "alias": "boundary"; "required": false; "isSignal": true; }; "dragRootElement": { "alias": "dragRootElement"; "required": false; "isSignal": true; }; "dragHandle": { "alias": "dragHandle"; "required": false; "isSignal": true; }; "lockAxis": { "alias": "lockAxis"; "required": false; "isSignal": true; }; "dragThreshold": { "alias": "dragThreshold"; "required": false; "isSignal": true; }; "keyboardStep": { "alias": "keyboardStep"; "required": false; "isSignal": true; }; "autoScroll": { "alias": "autoScroll"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; }; }, { "disabled": "disabledChange"; "dragStart": "dragStart"; "dragMove": "dragMove"; "dragEnd": "dragEnd"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxDraggable<any>, "[NgxDraggable],[ngxDraggable]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "boundary": { "alias": "boundary"; "required": false; "isSignal": true; }; "dragRootElement": { "alias": "dragRootElement"; "required": false; "isSignal": true; }; "dragHandle": { "alias": "dragHandle"; "required": false; "isSignal": true; }; "lockAxis": { "alias": "lockAxis"; "required": false; "isSignal": true; }; "dragThreshold": { "alias": "dragThreshold"; "required": false; "isSignal": true; }; "keyboardStep": { "alias": "keyboardStep"; "required": false; "isSignal": true; }; "autoScroll": { "alias": "autoScroll"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; }; }, { "disabled": "disabledChange"; "dragRootElement": "dragRootElementChange"; "dragHandle": "dragHandleChange"; "dragStart": "dragStart"; "dragMove": "dragMove"; "dragEnd": "dragEnd"; }, never, never, true, never>;
 }
 
 declare class NgxResizable {
@@ -341,15 +360,23 @@ declare class AutoScroller {
     private raf;
     private container;
     private speed;
+    private onTick?;
     private readonly edge;
     private readonly maxSpeed;
     constructor(edge?: number, maxSpeed?: number);
-    start(fromEl: HTMLElement): void;
-    /** Call on every pointermove with the current client coordinates. */
+    /** onTick اجرا می‌شود بعد از هر گام اسکرول، تا با آخرین موقعیت pointer، sort/placeholder به‌روز شود. */
+    start(fromEl: HTMLElement, onTick?: () => void): void;
+    /** فقط container را عوض می‌کند بدون قطع حلقه‌ی در حال اجرا یا صفر کردن speed. */
+    retarget(fromEl: HTMLElement): void;
     update(clientX: number, clientY: number): void;
     stop(): void;
     private tick;
 }
+declare function findScrollableAncestor(el: HTMLElement): HTMLElement | Window;
+declare function getScrollPosition(container: HTMLElement | Window): {
+    left: number;
+    top: number;
+};
 
 declare function moveItemInArray<T>(array: T[], from: number, to: number): void;
 declare function transferArrayItem<T>(src: T[], dst: T[], from: number, to: number): void;
@@ -364,5 +391,5 @@ declare function transferArrayItem<T>(src: T[], dst: T[], from: number, to: numb
  */
 declare function copyArrayItem<T = any>(currentArray: T[], targetArray: T[], currentIndex: number, targetIndex: number): void;
 
-export { AutoScroller, DragDropService, DragRef, DropListGroupRef, DropListRef, NGX_DRAGGABLE, NGX_DROPLIST, NGX_DROPLIST_GROUP, NGX_PLACEHOLDER, NgxDraggable, NgxDropList, NgxDropListGroup, NgxPlaceholder, NgxResizable, PlaceHolderRef, adjustForZoom, checkBoundX, checkBoundY, clampResizeWithinBoundary, copyArrayItem, getPageZoom, isRtl, moveItemInArray, resolveLogicalDirection, transferArrayItem };
+export { AutoScroller, DragDropService, DragRef, DropListGroupRef, DropListRef, NGX_DRAGGABLE, NGX_DROPLIST, NGX_DROPLIST_GROUP, NGX_PLACEHOLDER, NgxDraggable, NgxDropList, NgxDropListGroup, NgxPlaceholder, NgxResizable, PlaceHolderRef, adjustForZoom, checkBoundX, checkBoundY, clampResizeWithinBoundary, copyArrayItem, findScrollableAncestor, getPageZoom, getScrollPosition, isRtl, moveItemInArray, resolveLogicalDirection, transferArrayItem };
 export type { DragAxis, IDropEvent, IPosition, IResizableOutput, LogicalResizeDirection, ResizeDirection };

package/types/ngx-kit-gradient-picker.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { OnInit, OnDestroy, EventEmitter, ChangeDetectorRef, AfterViewInit, ElementRef, Renderer2, ViewContainerRef } from '@angular/core';
 import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
-import { BrowserService, RangeSliderComponent, OverlayService } from 'ngx-kit/shared';
+import { BrowserService, RangeSliderComponent, OverlayService } from 'ngx-kit/core';
 
 interface GradientStop {
     id: string;
@@ -13,8 +13,6 @@ type GradientType = 'linear' | 'radial';
 declare class NgxInputGradientComponent implements OnInit, OnDestroy, ControlValueAccessor, Validator {
     private cd;
     browserService: BrowserService;
-    theme: 'light' | 'dark';
-    set setTheme(val: 'light' | 'dark' | 'auto');
     change: EventEmitter<string>;
     defaultGradients: string[];
     resultGradient: string;
@@ -46,7 +44,7 @@ declare class NgxInputGradientComponent implements OnInit, OnDestroy, ControlVal
     setDefaultGradients(): void;
     onSelectDefault(item: string, i: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgxInputGradientComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgxInputGradientComponent, "ngx-input-gradient", never, { "setTheme": { "alias": "theme"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxInputGradientComponent, "ngx-input-gradient", never, {}, { "change": "change"; }, never, never, true, never>;
 }
 
 declare class NgxInputGradient implements AfterViewInit, OnDestroy, ControlValueAccessor, Validator {
@@ -55,7 +53,6 @@ declare class NgxInputGradient implements AfterViewInit, OnDestroy, ControlValue
     private viewContainerRef;
     private overlayService;
     setInputBackground: boolean;
-    theme: 'light' | 'dark' | 'auto';
     private _targetInput?;
     set ngxInputColor(el: HTMLInputElement | ElementRef<HTMLInputElement> | null | undefined | '');
     change: EventEmitter<string>;
@@ -76,11 +73,11 @@ declare class NgxInputGradient implements AfterViewInit, OnDestroy, ControlValue
     validate(control: AbstractControl): ValidationErrors | null;
     ngOnDestroy(): void;
     writeValue(val: any): void;
-    toggleColorPicker(): void;
+    toggle(): void;
     destroyPicker(): void;
     private emitChange;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgxInputGradient, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxInputGradient, "[ngxInputGradient]", never, { "setInputBackground": { "alias": "setInputBackground"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "ngxInputColor": { "alias": "ngxInputColor"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxInputGradient, "[ngxInputGradient]", never, { "setInputBackground": { "alias": "setInputBackground"; "required": false; }; "ngxInputColor": { "alias": "ngxInputColor"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
 }
 
 export { NgxInputGradient, NgxInputGradientComponent };

package/types/ngx-kit-menu.d.ts

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { TemplateRef, OnDestroy, ElementRef, ApplicationRef } from '@angular/core';
-import { OverlayRef, Placement, Alignment, OverlayService } from 'ngx-kit/shared';
+import { OverlayRef, Placement, Alignment, OverlayService } from 'ngx-kit/core';
 
 interface MenuContext {
     close(): void;

package/types/ngx-kit-time-picker.d.ts

@@ -1,7 +1,7 @@
 import * as ngx_kit_time_picker from 'ngx-kit/time-picker';
 import * as _angular_core from '@angular/core';
 import { OnInit, ElementRef, InjectionToken, Provider } from '@angular/core';
-import { BrowserService } from 'ngx-kit/shared';
+import { BrowserService } from 'ngx-kit/core';
 import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
 
 declare type NgxTimePickerMode = 'hour' | 'minute';