ngx-kit 7.4.0 → 8.0.1

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

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { TemplateRef, EventEmitter, InjectionToken, OnInit, OnDestroy, ElementRef, Renderer2 } from '@angular/core';
+import { TemplateRef, ApplicationRef, EventEmitter, InjectionToken, OnInit, OnDestroy, Renderer2, ElementRef, AfterContentInit } from '@angular/core';
 
 interface IPosition {
     x: number;
@@ -19,20 +19,49 @@ declare class DropListGroupRef {
 }
 
 declare class PlaceHolderRef {
+    /**
+     * Custom placeholder content, from `*ngxPlaceholder` inside the `ngxDropList`. When unset,
+     * `attach()` falls back to a shallow clone of the dragged element (previous behaviour).
+     *
+     * Example:
+     *
+     *   <div ngxDropList>
+     *     <span class="my-placeholder" *ngxPlaceholder></span>
+     *     ...
+     *   </div>
+     */
     tpl?: TemplateRef<unknown>;
+    /** Set by `NgxPlaceholder` so the embedded view can join Angular's change-detection tree. */
+    appRef?: ApplicationRef;
     dropList?: DropListRef;
     element?: HTMLElement;
     private _visible;
+    private _view?;
+    /** True once `this.element` was built from `tpl` (as opposed to the fallback clone). */
+    private isCustom;
     attach(container: HTMLElement, source: HTMLElement, reference?: Node | null): HTMLElement;
+    /** True while the currently attached element came from a custom `*ngxPlaceholder` template. */
+    get custom(): boolean;
     detach(): void;
     get visible(): boolean;
 }
 
+interface Point {
+    x: number;
+    y: number;
+}
+
 /**
- * DropListRef is intentionally generic, while the positional sorting strategy
- * works on DragRef<any>. The public DropList/DragRef relationship is invariant
- * because IDropEvent<T> contains T in a callback position. Keep the strongly
- * typed Set here, and narrow only at the DOM-local bridge / strategy boundary.
+ * A drop list.
+ *
+ * Membership (`_draggables`) only ever reflects which draggables *belong* to this list in the
+ * template. It is never changed by dragging. Everything that is transient during a drag lives
+ * in a single `SortSession` (see sorting/sort-session.ts) that is created when a drag enters
+ * the list and disposed when it leaves or the drag ends:
+ *
+ *  - the list the drag started in keeps its session for the whole drag (its placeholder holds
+ *    the item's original slot, so leaving and re-entering is stable);
+ *  - any other list gets a fresh session on every entry and drops it on every exit.
  */
 declare class DropListRef<T = any> {
     data?: T;
@@ -40,34 +69,182 @@ declare class DropListRef<T = any> {
     disableSort: boolean;
     connectedTo: HTMLElement[];
     dropListGroup?: DropListGroupRef | null;
+    /** Duration (ms) of the sibling slide animation. `0` disables animation. */
+    sortAnimationDuration: number;
     readonly _draggables: Set<DragRef<T>>;
     readonly onDrop: EventEmitter<IDropEvent<T>>;
-    private strategy;
-    private active;
-    private previousIndex;
+    /**
+     * Nesting: the nearest ENCLOSING drop list (null for a top-level list), and this list's own
+     * direct nested lists — i.e. lists whose nearest enclosing list is this one, not a list at any
+     * depth. Set by `NgxDropList` at init from a `skipSelf` DI lookup. Used for two things: (1)
+     * `depth` for "innermost wins" in `DragRef`'s target resolution, without any DOM `.contains()`
+     * calls on the hot path, and (2) cascading `_setAncestorOffset` (below) to every list nested
+     * inside an item that gets displaced by sorting, at any depth.
+     */
+    parentList: DropListRef<any> | null;
+    readonly childLists: Set<DropListRef<any>>;
+    private session;
     private placeholder?;
+    customPlaceholder?: PlaceHolderRef;
+    private activeDrag;
+    private isOrigin;
+    private hovered;
+    private hit;
+    /** Pre-insertion geometry of a foreign list, restored when the drag leaves it. */
+    private naturalHit;
+    private hitCached;
+    /**
+     * Screen-space offset contributed by displaced ANCESTOR item(s) (see `parentList` above).
+     * `{0,0}` outside of that (the overwhelmingly common case). Kept as a SUM of independent
+     * per-source contributions, not a single overwritten value: while the pointer hovers a
+     * FOREIGN (non-origin) list nested inside the origin's own displaced item, up to two ancestor
+     * sessions can be displacing this list at once — the origin's (frozen, still active further
+     * up) and that foreign list's own — and one clearing its contribution on release must not
+     * wipe out the other's, still-active, contribution.
+     */
+    private readonly ancestorContributions;
+    private ancestorOffset;
+    /** Entries this list itself pushed via a one-time placeholder-insertion reflow (see below). */
+    private readonly reflowContributions;
+    /** How many enclosing drop lists this one is nested inside. Root lists are depth 0. */
+    get depth(): number;
+    _registerChild(child: DropListRef<any>): void;
+    _unregisterChild(child: DropListRef<any>): void;
+    /**
+     * One ancestor SESSION's contribution to this list's total displacement just changed (or
+     * cleared, `{0,0}`). `source` identifies WHICH session — the list whose own item is doing the
+     * displacing — so that this list's own recomputed total is a SUM across every currently-active
+     * source, and cascades the SAME (source, offset) pair on to every nested list at any depth
+     * unchanged, so a list several levels down stays hit-testable at its true on-screen position
+     * regardless of which ancestor(s) are currently sorting.
+     */
+    _setAncestorOffset(source: DropListRef<any>, offset: Point): void;
+    /** Which of this list's DIRECT nested lists live inside `el`, notified of its new offset. */
+    private propagateOffset;
+    /** Rects, right now, of every `other` entry that contains one of this list's nested lists. */
+    private trackedEntryRects;
+    /** Turns the real reflow a fresh placeholder insertion just caused into ordinary offsets. */
+    private propagateReflow;
     addItem(item: DragRef<T>): void;
     removeItem(item: DragRef<T>): void;
     isConnectedTo(other: DropListRef<any>): boolean;
+    /**
+     * Measure the list and its clipping ancestors once, at drag start (or the moment a nested
+     * list becomes a candidate mid-drag). `measureHit` reads live `getBoundingClientRect()`s,
+     * which already include any `translate3d` an ancestor item's displacement has applied — so if
+     * this list is currently offset (nested inside a sibling that sorting is displacing right
+     * now), the measurement is normalized back to the zero-offset frame `_containsPoint` expects,
+     * by subtracting that offset straight back out. Without this, entering a nested list while
+     * its ancestor is mid-displacement would double-count the offset on every check afterwards.
+     */
+    _cacheGeometry(): void;
+    /**
+     * Is the point over the *visible* part of this list? Scroll-aware without re-measuring.
+     *
+     * The list box and every clipping ancestor are tracked separately because they react to scroll
+     * differently: scrolling a container moves the list but not the container's own clip window.
+     */
+    _containsPoint(x: number, y: number): boolean;
+    /** Approximate area, used to break ties between overlapping, unrelated lists. */
+    _area(): number;
+    _onScroll(): void;
+    /** Re-measure after a viewport resize. */
+    _refresh(): void;
+    /** Backwards-compatible entry point: makes this list the drag's target. */
     createPlaceholder(drag: DragRef<T>): PlaceHolderRef;
+    /** The drag pointer entered this list (or the drag started inside it). */
     enter(drag: DragRef<T>, x?: number, y?: number): void;
+    /** Re-evaluate the insertion index for the pointer. Returns the new index, or null if unchanged. */
     sortItem(drag: DragRef<T>, position: IPosition): number | null;
+    /** The pointer left this list. */
+    /**
+     * The pointer truly left this list (as opposed to moving deeper into one of its own nested
+     * lists — see `DragRef`'s chain tracking, which never calls `exit()` for a list that remains
+     * an ancestor of the new target, so this always means "left this list's territory").
+     */
+    exit(drag: DragRef<T>): void;
+    /**
+     * The pointer dove into one of this list's own nested lists: this list is no longer the
+     * innermost target, but it isn't being left either — its placeholder and sibling displacement
+     * stay exactly as they are (avoids a snap-back-then-forward flicker), only the "currently
+     * hovered" bookkeeping (and its visual highlight) is cleared. `DragRef`'s chain tracking calls
+     * this instead of `exit()` for every list that remains an ancestor of the new target.
+     */
+    _freeze(): void;
+    /**
+     * Ends the drag for this list. Returns the drop event when the pointer was released over this
+     * list, `null` otherwise (nothing to emit). All transient state is disposed either way.
+     */
+    _finish(drag: DragRef<T>, commit: boolean): IDropEvent<T> | null;
+    /** Compatibility wrapper: finish + emit. */
     finishDrag(drag: DragRef<T>): void;
-    exit(_drag: DragRef<T>): void;
     resetSortTransforms(): void;
     getFinalIndex(): number;
     getItemIndex(item: DragRef<T>): number;
+    /** End of the drag: dispose EVERYTHING this list holds, including cached geometry. Idempotent. */
+    _release(drag?: DragRef<T>): void;
+    /** Dispose the sort session, placeholder and drag ownership. */
+    private releaseSession;
+    private begin;
+    /**
+     * First placement into a list that does not contain the item yet: the node the placeholder
+     * must be inserted before (null = append). Same pure resolver as sorting, no hysteresis.
+     */
+    private foreignInsertionReference;
+    private otherSlots;
     private indexOf;
-    private reset;
-    private copyPlaceholderGeometry;
+    private lockPlaceholderGeometry;
+}
+
+declare class DragDropService {
+    readonly drags: _angular_core.WritableSignal<readonly DragRef<unknown>[]>;
+    readonly dropLists: _angular_core.WritableSignal<readonly DropListRef<any>[]>;
+    readonly activeDrag: _angular_core.WritableSignal<DragRef<unknown> | null>;
+    /**
+     * DOM-position registries, used to find the nearest enclosing list/group by walking real
+     * ancestor elements instead of Angular's element-injector tree.
+     *
+     * This matters for `ngTemplateOutlet`-based recursive trees (a list of items whose own
+     * children are rendered by re-invoking the SAME `<ng-template>`, as in a tree/outliner UI):
+     * each invocation gets a FRESH embedded view whose injector context is wherever the outlet
+     * was written in the template, not wherever its content ends up in the DOM. So `inject(TOKEN,
+     * {skipSelf})` from one recursion level can never see a provider from another level — the
+     * only fix within Angular's own DI is to manually thread `ngTemplateOutletInjector` through
+     * every recursive call, which isn't reasonable to require of every consumer of this library.
+     * A plain DOM walk has no such limitation: it only cares where elements actually ended up.
+     */
+    private readonly listsByEl;
+    private readonly groupsByEl;
+    registerDragItem(ref: DragRef<any>): void;
+    removeDragItem(ref: DragRef<any>): void;
+    registerDropList(ref: DropListRef): void;
+    removeDropList(ref: DropListRef<any>): void;
+    registerGroup(el: HTMLElement, ref: DropListGroupRef): void;
+    removeGroup(el: HTMLElement): void;
+    /** Nearest registered drop list starting at (and including) `start`, walking up the DOM. */
+    findAncestorDropList(start: HTMLElement | null): DropListRef | null;
+    /** Nearest registered drop-list group starting at (and including) `start`, walking up the DOM. */
+    findAncestorGroup(start: HTMLElement | null): DropListGroupRef | null;
+    begin(ref: DragRef<any>): void;
+    end(ref: DragRef<any>): void;
+    cancelActive(): void;
     /**
-     * The sorting strategy only needs a read-only collection of draggable refs.
-     * Using DragRef<any> at this internal boundary avoids the invariant generic
-     * relationship between DragRef<T> and DragRef<unknown>.
+     * Which drop list is under `point`?
+     *
+     * - Only lists connected to the drag's ORIGIN list qualify (connectivity is not transitive, so
+     *   A→B→C never lets an item hop A→C). Without an origin (a free-drag element) nothing
+     *   qualifies: free dragging is never captured by a list.
+     * - Only the visible (clip-aware) part of a list counts.
+     * - A list inside the dragged element itself is never a target.
+     * - Nested lists: the innermost qualifying list wins. Among unrelated overlapping lists the
+     *   current one is kept (no flicker), otherwise the smallest.
      */
-    private getStrategyItems;
-    private asStrategyDrag;
-    private publishDragItems;
+    findDropList(point: {
+        x: number;
+        y: number;
+    }, current?: DropListRef | null, origin?: DropListRef | null, dragEl?: HTMLElement | null): DropListRef | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DragDropService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DragDropService>;
 }
 
 type DragAxis = 'x' | 'y' | undefined;
@@ -76,8 +253,16 @@ declare class DragRef<T = unknown> {
     el: HTMLElement;
     boundary?: HTMLElement;
     lockAxis?: DragAxis;
+    /**
+     * The list this draggable BELONGS to (set by the template). Dragging never changes it.
+     * The list the pointer is currently over is `activeDropList`.
+     */
     dropList: DropListRef<T> | null;
     dropListGroup?: DropListGroupRef | null;
+    /** Used to find the drop list under the pointer. Set by the directive; optional. */
+    service?: DragDropService;
+    /** Drop list currently under the pointer during a drop-list drag (null = outside every list). */
+    activeDropList: DropListRef<T> | null;
     placeholder?: PlaceHolderRef;
     originDropList: DropListRef<T> | null;
     originIndex: number;
@@ -97,6 +282,21 @@ declare class DragRef<T = unknown> {
     private sourceVisibility;
     private sourceDisplay;
     private sourcePointerEvents;
+    private sourceTransition;
+    /** True while a drop-list drag (body preview + placeholder) is in progress. Free drag: always false. */
+    private listDrag;
+    private cachedLists;
+    /**
+     * Candidate lists for hit-testing, filtered (connected to the origin; not inside the dragged
+     * element) and sorted deepest-first — both computed ONCE, not on every pointer move, since
+     * neither ever changes mid-drag. Kept in sync with the live registry (see `dropListsSnapshot`)
+     * so a list that appears or disappears mid-drag (e.g. behind an `@if`) is still picked up.
+     */
+    private dropCandidates;
+    private dropListsSnapshot;
+    private lastEffective;
+    private scrollListener?;
+    private resizeListener?;
     init(): void;
     withDropList(list: DropListRef<T> | null): this;
     clearDropList(): void;
@@ -106,6 +306,12 @@ declare class DragRef<T = unknown> {
     nudge(dx: number, dy: number): void;
     endDrag(): void;
     cancelDrag(): void;
+    /** Abort without emitting anything (the directive was destroyed mid-drag). Idempotent. */
+    dispose(): void;
+    /** True while a drop-list drag is running. */
+    get isListDrag(): boolean;
+    /** Inline `display` the source element had before it was hidden for the drag. */
+    get originalDisplay(): string;
     get x(): number;
     get y(): number;
     get pointer(): IPosition;
@@ -118,6 +324,42 @@ declare class DragRef<T = unknown> {
      */
     notifyScroll(dx: number, dy: number): void;
     private applyTransform;
+    private beginListDrag;
+    /**
+     * Recomputes which registered lists are valid targets for this drag — connected to the
+     * origin, and not nested inside the element being dragged — plus each one's nesting depth.
+     *
+     * `DragDropService.dropLists()` is an Angular signal: its array is a NEW reference only when a
+     * list actually registers or unregisters, so the check below is a single reference comparison
+     * on every pointer move and the (heavier) connectivity/containment/depth work below it only
+     * runs on the rare event a list appears or disappears mid-drag — never on every pointer move.
+     */
+    private refreshDropCandidates;
+    /**
+     * Decide which list is under the pointer, switch if needed, then re-sort in the active one.
+     *
+     * The origin list is the one exception to "exiting a list resets/releases it": while the
+     * pointer dives into one of the origin's OWN nested lists (at any depth), the origin's
+     * placeholder and sibling displacement are left exactly as they are — frozen, not reset —
+     * so returning to the origin's own level doesn't snap items back and then forward again.
+     * Every OTHER (foreign) list still fully releases the moment the pointer leaves it, exactly
+     * as before; nesting multiple foreign sessions alive at once would let their own internal
+     * sibling displacement compound in ways a single flat `ancestorOffset` cannot represent.
+     */
+    private updateDropTarget;
+    /**
+     * Innermost connected list under the pointer, from the precomputed candidates: deeper always
+     * beats shallower; among lists at the same depth (unrelated, visually overlapping lists) the
+     * currently active one is kept to avoid flicker, otherwise the smaller one wins. No DOM
+     * reads and no `.contains()` calls happen here — everything needed was precomputed above.
+     */
+    private resolveDropList;
+    /**
+     * Single teardown path for every way a drop-list drag can end (drop on a list, drop outside,
+     * Escape, pointercancel, destroy). Everything transient is removed here, so nothing can leak
+     * regardless of how the drag ended. Only then is the drop event emitted.
+     */
+    private finishListDrag;
     private updatePreview;
 }
 
@@ -148,29 +390,9 @@ interface IResizableOutput {
     direction: ResizeDirection;
 }
 
-declare class DragDropService {
-    readonly drags: _angular_core.WritableSignal<readonly DragRef<unknown>[]>;
-    readonly dropLists: _angular_core.WritableSignal<readonly DropListRef<any>[]>;
-    readonly activeDrag: _angular_core.WritableSignal<DragRef<unknown> | null>;
-    registerDragItem(ref: DragRef<any>): void;
-    removeDragItem(ref: DragRef<any>): void;
-    registerDropList(ref: DropListRef): void;
-    removeDropList(ref: DropListRef<any>): void;
-    begin(ref: DragRef<any>): void;
-    end(ref: DragRef<any>): void;
-    cancelActive(): void;
-    findDropList(point: {
-        x: number;
-        y: number;
-    }, current?: DropListRef | null): DropListRef | null;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DragDropService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DragDropService>;
-}
-
 declare const NGX_DRAGGABLE: InjectionToken<NgxDraggable<unknown>>;
 declare class NgxDraggable<T = unknown> implements OnInit, OnDestroy {
     private readonly host;
-    private readonly renderer;
     readonly disabled: _angular_core.ModelSignal<boolean>;
     /** Element whose rect constrains the drag. Now actually enforced. */
     readonly boundary: _angular_core.InputSignal<HTMLElement | undefined>;
@@ -193,8 +415,6 @@ declare class NgxDraggable<T = unknown> implements OnInit, OnDestroy {
     readonly dragging: _angular_core.WritableSignal<boolean>;
     private readonly doc;
     private readonly service;
-    private readonly list;
-    private readonly group;
     private readonly scroller;
     private down;
     private start;
@@ -205,12 +425,15 @@ declare class NgxDraggable<T = unknown> implements OnInit, OnDestroy {
     private removeUp?;
     private removeKeydown?;
     private removeEscape?;
+    private removeCancel?;
+    private removeLostCapture?;
     private scrollTarget;
     private lastScroll;
     private lastWindowScroll;
     private removeContainerScroll?;
     private removeWindowScroll?;
-    constructor(host: ElementRef<HTMLElement>, renderer: Renderer2);
+    protected readonly renderer: Renderer2;
+    constructor(host: ElementRef<HTMLElement>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     private pointerDown;
@@ -222,6 +445,8 @@ declare class NgxDraggable<T = unknown> implements OnInit, OnDestroy {
     private stopScrollTracking;
     private pointerMove;
     private pointerUp;
+    /** Browser cancelled the pointer (touch takeover, lost capture...). */
+    private pointerCancel;
     private cancel;
     private finish;
     /** Arrow-key movement for keyboard/assistive-tech users. Shift multiplies the step by 4. */
@@ -277,26 +502,31 @@ declare class NgxResizable {
 }
 
 declare const NGX_DROPLIST: InjectionToken<NgxDropList<any>>;
-declare class NgxDropList<T = any> implements OnInit, OnDestroy {
+declare class NgxDropList<T = any> implements OnInit, OnDestroy, AfterContentInit {
     private readonly el;
     readonly _ref: DropListRef<T>;
     set data(value: T);
     set connectedTo(value: HTMLElement[] | null | undefined);
     set disableSort(value: boolean);
     readonly drop: EventEmitter<IDropEvent<T>>;
+    private readonly customPlaceholder?;
+    private sub?;
     private readonly service;
-    private readonly group;
     constructor(el: ElementRef<HTMLElement>);
     ngOnInit(): void;
+    ngAfterContentInit(): void;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxDropList<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxDropList<any>, "[NgxDropList],[ngxDropList]", never, { "data": { "alias": "data"; "required": false; }; "connectedTo": { "alias": "connectedTo"; "required": false; }; "disableSort": { "alias": "disableSort"; "required": false; }; }, { "drop": "drop"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxDropList<any>, "[NgxDropList],[ngxDropList]", never, { "data": { "alias": "data"; "required": false; }; "connectedTo": { "alias": "connectedTo"; "required": false; }; "disableSort": { "alias": "disableSort"; "required": false; }; }, { "drop": "drop"; }, ["customPlaceholder"], never, true, never>;
 }
 
 declare const NGX_DROPLIST_GROUP: InjectionToken<NgxDropListGroup>;
 /** Wrap several `ngxDropList`s to let items move freely between them. */
-declare class NgxDropListGroup implements OnDestroy {
+declare class NgxDropListGroup implements OnInit, OnDestroy {
     readonly _ref: DropListGroupRef;
+    private readonly el;
+    private readonly service;
+    ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxDropListGroup, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxDropListGroup, "[NgxDropListGroup],[ngxDropListGroup]", never, {}, {}, never, never, true, never>;

package/types/{ngx-kit-gallery.d.ts → ngx-kit-image-viewer.d.ts}

@@ -4,13 +4,8 @@ interface NgxImageViewerItem {
     src: string;
     alt?: string;
     caption?: string;
-    /** نام فایل هنگام دانلود؛ نبود یعنی از روی src حدس زده می‌شه */
     downloadFileName?: string;
 }
-/**
- * هر دکمه‌ی نوار ابزار جدا فعال/غیرفعال می‌شه — دقیقاً طبق خواسته: «این
- * دکمه‌های کانفیگی باشه که هر کدوم خواست فعال کنه».
- */
 interface NgxImageViewerToolbarConfig {
     prevNext?: boolean;
     counter?: boolean;
@@ -47,7 +42,7 @@ declare const NGX_IMAGE_VIEWER_DEFAULT_TOOLBAR: Required<NgxImageViewerToolbarCo
  * ngx-kit/dialog (یا هر overlay دیگه) قرار بگیره — خودش به هیچ‌کدوم وابسته
  * نیست، فقط با closed خروجی به بیرون خبر می‌ده که «ببندم».
  */
-declare class NgxImageViewerComponent {
+declare class NgxImageViewer {
     images: _angular_core.InputSignal<NgxImageViewerItem[]>;
     startIndex: _angular_core.InputSignal<number>;
     toolbar: _angular_core.InputSignal<NgxImageViewerToolbarConfig>;
@@ -103,37 +98,8 @@ declare class NgxImageViewerComponent {
     private applyZoomAt;
     private clientXOf;
     private clientYOf;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxImageViewerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxImageViewerComponent, "ngx-image-viewer", never, { "images": { "alias": "images"; "required": true; "isSignal": true; }; "startIndex": { "alias": "startIndex"; "required": false; "isSignal": true; }; "toolbar": { "alias": "toolbar"; "required": false; "isSignal": true; }; "minZoom": { "alias": "minZoom"; "required": false; "isSignal": true; }; "maxZoom": { "alias": "maxZoom"; "required": false; "isSignal": true; }; "zoomStep": { "alias": "zoomStep"; "required": false; "isSignal": true; }; }, { "indexChange": "indexChange"; "closed": "closed"; }, never, never, true, never>;
-}
-
-interface NgxImageViewerOpenOptions {
-    startIndex?: number;
-    toolbar?: NgxImageViewerToolbarConfig;
-    minZoom?: number;
-    maxZoom?: number;
-    zoomStep?: number;
-}
-/**
- * راه میان‌بر برای وقتی که کاربر می‌خواد ویوئر رو داخل یه دیالوگِ تمام‌صفحه
- * باز کنه، بدون این‌که خودش دستی wire کنه. اگه کسی می‌خواد داخل دیالوگِ
- * خودش (مثلاً ngx-kit/dialog) بذارتش، کافیه مستقیم از NgxImageViewerComponent
- * استفاده کنه — این سرویس صرفاً یه میان‌بَره، وابستگی اجباری نیست.
- *
- * دقیقاً همون الگوی امن‌شده‌ی NgxMessageService: با Map<id, ComponentRef> و
- * detachView قبل از destroy، تا اون نشتی حافظه‌ای که قبلاً توی message
- * service پیدا و رفع شد، اینجا از اول تکرار نشه.
- */
-declare class NgxImageViewerService {
-    private readonly appRef;
-    private readonly envInjector;
-    private nextId;
-    private readonly openInstances;
-    open(images: NgxImageViewerItem[], options?: NgxImageViewerOpenOptions): {
-        close: () => void;
-    };
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxImageViewerService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgxImageViewerService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxImageViewer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxImageViewer, "ngx-image-viewer", never, { "images": { "alias": "images"; "required": true; "isSignal": true; }; "startIndex": { "alias": "startIndex"; "required": false; "isSignal": true; }; "toolbar": { "alias": "toolbar"; "required": false; "isSignal": true; }; "minZoom": { "alias": "minZoom"; "required": false; "isSignal": true; }; "maxZoom": { "alias": "maxZoom"; "required": false; "isSignal": true; }; "zoomStep": { "alias": "zoomStep"; "required": false; "isSignal": true; }; }, { "indexChange": "indexChange"; "closed": "closed"; }, never, never, true, never>;
 }
 
 interface PanZoomState {
@@ -164,5 +130,5 @@ declare function downloadImage(src: string, filename?: string): Promise<void>;
 /** یه پنجره‌ی جدید فقط با همون تصویر باز می‌کنه و بعد از لود، print می‌زنه؛ با DOM API (نه innerHTML) پس در برابر src مخرب امنه */
 declare function printImage(src: string): void;
 
-export { NGX_IMAGE_VIEWER_DEFAULT_TOOLBAR, NgxImageViewerComponent, NgxImageViewerService, clamp, distanceBetweenTouches, downloadImage, midpointOfTouches, printImage, zoomAroundPoint };
-export type { NgxImageViewerItem, NgxImageViewerOpenOptions, NgxImageViewerToolbarConfig, PanZoomState };
+export { NGX_IMAGE_VIEWER_DEFAULT_TOOLBAR, NgxImageViewer, clamp, distanceBetweenTouches, downloadImage, midpointOfTouches, printImage, zoomAroundPoint };
+export type { NgxImageViewerItem, NgxImageViewerToolbarConfig, PanZoomState };

package/types/ngx-kit-side-nav.d.ts

@@ -0,0 +1,53 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, OnDestroy } from '@angular/core';
+import * as ngx_kit_side_nav from 'ngx-kit/side-nav';
+
+declare class NgxDrawerMenu {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDrawerMenu, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDrawerMenu, "[ngxDrawerMenu]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgxDrawerMenuToggle {
+    readonly hideOnBreakPoint: i0.InputSignal<boolean>;
+    protected readonly sideNav: ngx_kit_side_nav.NgxSideNav;
+    hide: i0.WritableSignal<boolean>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDrawerMenuToggle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDrawerMenuToggle, "[ngxDrawerMenuToggle]", never, { "hideOnBreakPoint": { "alias": "hideOnBreakPoint"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NgxSideNavMode = 'push' | 'overlay';
+
+declare const NGX_SIDE_NAV: InjectionToken<NgxSideNav>;
+declare class NgxSideNav implements OnInit, OnDestroy {
+    readonly open: i0.ModelSignal<boolean>;
+    readonly width: i0.InputSignal<number>;
+    readonly breakpoint: i0.InputSignal<number | null>;
+    readonly mode: i0.InputSignal<NgxSideNavMode>;
+    shouldShowOverlay: i0.WritableSignal<boolean>;
+    private mediaQuery?;
+    readonly isMatchMediaQuery: i0.WritableSignal<boolean>;
+    private removeMediaQueryListener?;
+    protected readonly win: Window | null;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    initialize(): void;
+    setupMediaQuery(): void;
+    onResize(): void;
+    toggleMenu(): void;
+    closeMenu(): void;
+    openMenu(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxSideNav, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxSideNav, "ngx-side-nav", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "breakpoint": { "alias": "breakpoint"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["[ngxDrawerMenu]", "*"], true, never>;
+}
+
+declare class NgxSideNavModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxSideNavModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxSideNavModule, never, [typeof NgxDrawerMenu, typeof NgxDrawerMenuToggle, typeof NgxSideNav], [typeof NgxDrawerMenu, typeof NgxDrawerMenuToggle, typeof NgxSideNav]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxSideNavModule>;
+}
+
+export { NGX_SIDE_NAV, NgxDrawerMenu, NgxDrawerMenuToggle, NgxSideNav, NgxSideNavModule };
+export type { NgxSideNavMode };