ngx-kit 3.2.0 → 5.0.0

package/types/ngx-kit-data-table.d.ts

@@ -0,0 +1,334 @@
+import * as _angular_core from '@angular/core';
+import { InputSignal, Type, TemplateRef, InjectionToken, EnvironmentProviders, OnInit, AfterContentInit } from '@angular/core';
+import * as ngx_kit_shared from 'ngx-kit/shared';
+import * as ngx_kit_data_table from 'ngx-kit/data-table';
+
+type SortDirection = 'asc' | 'desc';
+interface SortMeta<T> {
+    field: Extract<keyof T, string>;
+    direction: SortDirection;
+}
+
+interface PageEvent {
+    page: number;
+    pageSize: number;
+}
+interface PageState {
+    pageIndex: number;
+    pageSize: number;
+    /** آفست صفر-پایه‌ی اولین ردیف صفحه‌ی جاری. */
+    first: number;
+}
+/** هر بار سرور باید صفحه‌ی جدید را (در حالت lazy) واکشی کند، امیت می‌شود. */
+interface LazyLoadEvent<T> extends PageState {
+    sorts: SortMeta<T>[];
+}
+
+interface PaginationLabel {
+    first: string;
+    last: string;
+    next: string;
+    previous: string;
+    showing: string;
+    to: string;
+    of: string;
+    results: string;
+    pageSize: string;
+}
+interface NgxPaginationOptions {
+    labels: PaginationLabel;
+    pageSizeOptions: number[];
+    defaultPageSize: number;
+}
+
+interface CellRendererComponent<TValue = unknown, TRow extends object = object> {
+    value: InputSignal<TValue>;
+    row: InputSignal<TRow>;
+    field: InputSignal<TableFieldBase<TRow>>;
+}
+type RendererRegistry = Readonly<Record<string, Type<CellRendererComponent<any, any>>>>;
+/**
+ * Identity helper: یک رجیستری رندرر را با inference کامل تعریف می‌کند.
+ * همین آبجکت باید هم در provideTable({ renderers }) و هم در defineFields(renderers, ...)
+ * استفاده شود تا کلیدها (و ورودی‌های اضافه‌ی هر رندرر) در کل پروژه type-check شوند.
+ */
+declare function defineRenderers<R extends RendererRegistry>(registry: R): R;
+type InstanceOf<C> = C extends Type<infer I> ? I : never;
+type UnwrapSignal<S> = S extends () => infer V ? V : never;
+type RendererExtraInputs<C extends Type<any>> = {
+    [K in keyof InstanceOf<C> as K extends 'value' | 'row' | 'field' ? never : InstanceOf<C>[K] extends () => any ? K : never]?: UnwrapSignal<InstanceOf<C>[K]>;
+};
+type ColumnAlign = 'start' | 'center' | 'end';
+type TableCellFormatter<T extends object = object> = (value: unknown, row: T, field: TableFieldBase<T>) => unknown;
+interface CellTemplateContext<T extends object> {
+    $implicit: T;
+    row: T;
+    value: unknown;
+    rowIndex: number;
+    field: TableFieldBase<T>;
+}
+/** شکل پایه‌ای مشترک بین همه‌ی ستون‌ها، صرف‌نظر از این‌که renderer دارند یا نه. */
+interface TableFieldBase<T extends object> {
+    column: Extract<keyof T, string>;
+    title: string;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    resizable?: boolean;
+    sortable?: boolean;
+    wrap?: boolean;
+    align?: ColumnAlign;
+    prefix?: string;
+    formatter?: string | TableCellFormatter<T>;
+}
+/** ستون بدون renderer (متن ساده / formatter / cellTemplate دستی). */
+interface PlainTableField<T extends object> extends TableFieldBase<T> {
+    renderer?: undefined;
+    rendererInputs?: undefined;
+    cellTemplate?: TemplateRef<CellTemplateContext<T>>;
+}
+/** ستونی که یک renderer از رجیستری R انتخاب کرده؛ rendererInputs دقیقاً همان
+ *  ورودی‌های اضافه‌ی همان renderer است — نه یک Record<string, unknown> آزاد. */
+type RenderedTableField<T extends object, R extends RendererRegistry> = {
+    [K in keyof R]: TableFieldBase<T> & {
+        renderer: K;
+        rendererInputs?: RendererExtraInputs<R[K]>;
+        cellTemplate?: undefined;
+    };
+}[keyof R];
+type TableField<T extends object, R extends RendererRegistry = {}> = PlainTableField<T> | RenderedTableField<T, R>;
+/**
+ * Identity helper برای تعریف ستون‌های یک جدول با inference و type-check کامل
+ * نسبت به هم مدل داده (T) و هم رجیستری رندررها (R).
+ *
+ * @example
+ * const renderers = defineRenderers({ avatar: AvatarCellRenderer, boolean: BooleanCellRenderer });
+ *
+ * const fields = defineFields<Tenant, typeof renderers>(renderers, [
+ *   { column: 'avatarUrl', title: 'کاربر', renderer: 'avatar', rendererInputs: { showName: true } }, // ✅
+ *   { column: 'avatarUrl', title: 'کاربر', renderer: 'avatar', rendererInputs: { showName: 'x' } },  // ❌ باید boolean باشد
+ *   { column: 'isActive',  title: 'فعال', renderer: 'bool' },                                        // ❌ کلید رجیستری نیست
+ *   { column: 'ageXYZ',    title: '...' },                                                            // ❌ فیلد Tenant نیست
+ * ]);
+ */
+declare function defineFields<T extends object, R extends RendererRegistry = {}>(_renderers: R, fields: TableField<T, R>[]): TableField<T, R>[];
+
+interface TableLabels {
+    operation?: string;
+    noData?: string;
+    loading?: string;
+}
+interface ColumnSizingConfig {
+    /** حداقل عرض (px) که برای همه‌ی ستون‌های resizable اعمال می‌شود مگر این‌که ستون خودش override کند. */
+    minWidth: number;
+    /** حداکثر عرض (px). */
+    maxWidth: number;
+    /** عرض پیش‌فرض وقتی ستون width مشخص نکرده و کاربر هم دستی ریسایز نکرده. */
+    defaultWidth: number;
+}
+interface NgxTableOptions {
+    showRecordNumber?: boolean;
+    labels?: TableLabels;
+    /** فعال‌سازی سورت چندستونه با Ctrl/Shift+Click. */
+    multiSort?: boolean;
+    resizable?: boolean;
+    stripedRows?: boolean;
+    hoverable?: boolean;
+    stickyHeader?: boolean;
+    column?: ColumnSizingConfig;
+    /** رجیستری رندررهای سراسری. با defineRenderers({...}) بسازید. */
+    renderers?: RendererRegistry;
+    formatters?: Readonly<Record<string, TableCellFormatter<any>>>;
+}
+type ResolvedTableOptions = Required<Omit<NgxTableOptions, 'labels' | 'renderers' | 'formatters'>> & {
+    labels: Required<TableLabels>;
+    renderers: RendererRegistry;
+    formatters: Readonly<Record<string, TableCellFormatter<any>>>;
+};
+
+declare const NGX_TABLE_CONFIG_DEFAULT: ResolvedTableOptions;
+/** به هر نمونه‌ی ngx-table تزریق می‌شود. با provideTable() مقداردهی کنید. */
+declare const NGX_TABLE_CONFIG: InjectionToken<ResolvedTableOptions>;
+
+declare const NGX_PAGINATION_CONFIG_DEFAULT: NgxPaginationOptions;
+declare const NGX_PAGINATION_CONFIG: InjectionToken<NgxPaginationOptions>;
+
+/**
+ * کانفیگ سراسری <ngx-table>: جهت پیش‌فرض، حداقل/حداکثر عرض ستون، فعال بودن
+ * پیش‌فرض سورت چندستونه، و از همه مهم‌تر رجیستری رندررها.
+ *
+ * @example
+ * provideTable({
+ *   renderers: defineRenderers({ avatar: AvatarCellRenderer, boolean: BooleanCellRenderer }),
+ *   column: { minWidth: 80, maxWidth: 480, defaultWidth: 160 },
+ * })
+ */
+declare function provideTable(options?: NgxTableOptions): EnvironmentProviders;
+
+declare function providePagination(options?: Partial<NgxPaginationOptions>): EnvironmentProviders;
+
+/**
+ * برای projection قالب سفارشی یک ستون بدون این‌که مجبور باشید cellTemplate را
+ * از طریق ViewChild به آبجکت ستون وصل کنید:
+ *
+ *   <ngx-table [fields]="fields" [data]="rows()">
+ *     <ng-template ngxTableCell="userName" let-row let-value="value">
+ *       <strong>{{ value }}</strong>
+ *     </ng-template>
+ *   </ngx-table>
+ *
+ * مهم: چون این دایرکتیو در تمپلیت *کامپوننت مصرف‌کننده* (نه ngx-table) استفاده
+ * می‌شود، باید آن را در آرایه‌ی imports همان کامپوننت (standalone) وارد کنید:
+ *   imports: [NgxTable, TableCell]
+ *
+ * محدودیت شناخته‌شده: context این تمپلیت (row/value) از نوع T دقیق نیست
+ * (چون TemplateRef اینجا به‌صورت پویا از ContentChildren جمع‌آوری می‌شود و
+ * اطلاعات جنریک T در آن نقطه از بین می‌رود). برای type-safety کامل روی
+ * row/value، از field.cellTemplate به همراه @ViewChild استفاده کنید (به README
+ * بخش «Cell Template کاملاً Type-Safe» مراجعه کنید).
+ */
+declare class TableCell<T extends object = object> {
+    readonly column: _angular_core.InputSignal<string>;
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableCell<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableCell<any>, "ng-template[ngxTableCell]", never, { "column": { "alias": "ngxTableCell"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * دستگیره‌ی درگ برای ریسایز ستون. روی لبه‌ی «انتهای منطقی» (inline-end) قرار
+ * می‌گیرد، یعنی خودش زیر [dir="rtl"] جابه‌جا می‌شود؛ فقط جهت محاسبه‌ی دلتا هم
+ * برعکس می‌شود تا حس درگ همیشه طبیعی باشد.
+ *
+ * مقدار نهایی توسط جدول در یک Map از عرض‌ها ذخیره می‌شود (نه در استایل مستقیم
+ * ستون)، به همراه علامت‌گذاری «دستی ریسایز شده» — یعنی بعد از این، هیچ
+ * re-render یا تغییر داده‌ای این عرض را از بین نمی‌برد.
+ */
+declare class ColumnResize {
+    readonly startWidth: _angular_core.InputSignal<number>;
+    readonly minWidth: _angular_core.InputSignal<number>;
+    readonly maxWidth: _angular_core.InputSignal<number>;
+    readonly direction: _angular_core.InputSignal<"ltr" | "rtl">;
+    readonly resizing: _angular_core.OutputEmitterRef<number>;
+    readonly resizeEnd: _angular_core.OutputEmitterRef<number>;
+    private dragging;
+    private startX;
+    private baseWidth;
+    onPointerDown(event: PointerEvent): void;
+    onPointerMove(event: PointerEvent): void;
+    onPointerUp(event: PointerEvent): void;
+    private computeWidth;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColumnResize, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ColumnResize, "[ngxColumnResize]", never, { "startWidth": { "alias": "ngxColumnResizeWidth"; "required": true; "isSignal": true; }; "minWidth": { "alias": "ngxColumnResizeMin"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "ngxColumnResizeMax"; "required": false; "isSignal": true; }; "direction": { "alias": "ngxColumnResizeDir"; "required": false; "isSignal": true; }; }, { "resizing": "resizing"; "resizeEnd": "resizeEnd"; }, never, never, true, never>;
+}
+
+/**
+ * جدول داده‌ی جنریک و Type-Safe.
+ *
+ * `T` از روی چیزی که به [data] بایند می‌کنید استنتاج می‌شود؛ `field.column` در
+ * `TableField<T, R>` محدود به `keyof T` است، و اگر از defineFields(renderers, ...)
+ * استفاده کنید، `field.renderer` محدود به کلیدهای رجیستری و `rendererInputs`
+ * دقیقاً همان ورودی‌های اضافه‌ی همان renderer است.
+ *
+ * دو حالت:
+ *  - کلاینت‌ساید (پیش‌فرض): [data] کل آرایه است؛ سورت/صفحه‌بندی داخلی و روی
+ *    یک computed خالص انجام می‌شود (بدون mutation روی آبجکت‌های شما).
+ *  - lazy: [lazy]="true" + [totalRecords]؛ [data] فقط صفحه‌ی جاری است؛ به
+ *    (lazyLoad) گوش بدهید.
+ */
+declare class NgxTable<T extends object> implements OnInit, AfterContentInit {
+    protected readonly config: ngx_kit_data_table.ResolvedTableOptions;
+    protected readonly paginationConfig: ngx_kit_data_table.NgxPaginationOptions;
+    readonly fields: _angular_core.InputSignal<TableField<T, any>[]>;
+    readonly data: _angular_core.InputSignal<readonly T[]>;
+    readonly totalRecords: _angular_core.InputSignal<number>;
+    readonly showRecordNumber: _angular_core.InputSignal<boolean>;
+    readonly operations: _angular_core.InputSignal<TemplateRef<{
+        $implicit: T;
+    }> | undefined>;
+    readonly operationWidth: _angular_core.InputSignal<number>;
+    readonly numWidth: _angular_core.InputSignal<number>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly multiSort: _angular_core.InputSignal<boolean | undefined>;
+    readonly lazy: _angular_core.InputSignal<boolean>;
+    /** پیش‌فرض بر اساس ایندکس؛ برای جلوگیری از گم‌شدن state سطرها هنگام سورت،
+     *  یک شناسه‌ی یکتا بدهید: [trackBy]="(i, row) => row.id" */
+    readonly trackBy: _angular_core.InputSignal<(index: number, row: T) => unknown>;
+    readonly lazyLoad: _angular_core.OutputEmitterRef<LazyLoadEvent<T>>;
+    readonly sortChange: _angular_core.OutputEmitterRef<SortMeta<T>[]>;
+    readonly columnResize: _angular_core.OutputEmitterRef<{
+        field: string;
+        width: number;
+    }>;
+    protected readonly page: _angular_core.WritableSignal<number>;
+    protected readonly pageSizeS: _angular_core.WritableSignal<number>;
+    protected readonly sorts: _angular_core.WritableSignal<SortMeta<T>[]>;
+    protected readonly widths: _angular_core.WritableSignal<Record<string, number>>;
+    private readonly manuallyResized;
+    private readonly rendererInputsCache;
+    private cellTemplates;
+    private templateMap;
+    protected readonly resolvedMultiSort: _angular_core.Signal<boolean>;
+    private readonly directionService;
+    protected readonly resolvedDirection: _angular_core.Signal<ngx_kit_shared.Direction>;
+    constructor();
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    private syncTemplateMap;
+    protected readonly sortedData: _angular_core.Signal<readonly T[]>;
+    protected readonly totalCount: _angular_core.Signal<number>;
+    protected readonly pagedData: _angular_core.Signal<readonly T[]>;
+    private compare;
+    /** بدون mutation روی داده‌ی ورودی: شماره‌ی ردیف صرفاً از روی page/pageSize/rowIndex محاسبه می‌شود. */
+    protected recordNumber(rowIndex: number): number;
+    protected sortDirectionFor(column: string): SortDirection | null;
+    protected onHeaderClick(field: TableField<T, any>, event: MouseEvent): void;
+    protected onPaginate(event: PageEvent): void;
+    private emitLazyIfNeeded;
+    protected columnWidth(column: string): number;
+    protected columnMin(field: TableField<T, any>): number;
+    protected columnMax(field: TableField<T, any>): number;
+    protected isResizable(field: TableField<T, any>): boolean;
+    protected onColumnResizing(column: string, width: number): void;
+    protected onColumnResizeEnd(column: string, width: number): void;
+    protected getTemplate(column: string): TemplateRef<CellTemplateContext<T>> | null;
+    protected getRenderer(field: TableField<T, any>): Type<CellRendererComponent> | null;
+    protected getCellValue(row: T, field: TableField<T, any>): unknown;
+    protected formatCellValue(row: T, field: TableField<T, any>): string;
+    private stringify;
+    /** ورودی‌های renderer را به‌ازای هر (field, row) کش می‌کند تا هر Change
+     *  Detection یک آبجکت جدید ساخته نشود؛ با WeakMap، وقتی row از حافظه خارج
+     *  شود (مثلاً بعد از عوض‌شدن صفحه)، entry آن هم خودکار پاک می‌شود. */
+    protected getRendererInputs(row: T, field: TableField<T, any>): Record<string, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxTable<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxTable<any>, "ngx-table", never, { "fields": { "alias": "fields"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": true; "isSignal": true; }; "totalRecords": { "alias": "totalRecords"; "required": true; "isSignal": true; }; "showRecordNumber": { "alias": "showRecordNumber"; "required": false; "isSignal": true; }; "operations": { "alias": "operations"; "required": false; "isSignal": true; }; "operationWidth": { "alias": "operationWidth"; "required": false; "isSignal": true; }; "numWidth": { "alias": "numWidth"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "multiSort": { "alias": "multiSort"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; }, { "lazyLoad": "lazyLoad"; "sortChange": "sortChange"; "columnResize": "columnResize"; }, ["cellTemplates"], never, true, never>;
+}
+
+declare class NgxPagination {
+    protected readonly config: ngx_kit_data_table.NgxPaginationOptions;
+    readonly total: _angular_core.InputSignal<number>;
+    readonly page: _angular_core.ModelSignal<number>;
+    readonly pageSize: _angular_core.ModelSignal<number>;
+    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
+    readonly labels: _angular_core.InputSignal<ngx_kit_data_table.PaginationLabel>;
+    readonly siblingCount: _angular_core.InputSignal<number>;
+    readonly boundaryCount: _angular_core.InputSignal<number>;
+    readonly paginate: _angular_core.OutputEmitterRef<PageEvent>;
+    protected readonly totalPages: _angular_core.Signal<number>;
+    protected readonly firstItem: _angular_core.Signal<number>;
+    protected readonly lastItem: _angular_core.Signal<number>;
+    protected readonly pages: _angular_core.Signal<(string | number)[]>;
+    constructor();
+    private buildPages;
+    protected next(): void;
+    protected previous(): void;
+    protected first(): void;
+    protected last(): void;
+    protected goto(page: number): void;
+    protected onPageSizeChange(value: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxPagination, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxPagination, "ngx-pagination", never, { "total": { "alias": "total"; "required": true; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "siblingCount": { "alias": "siblingCount"; "required": false; "isSignal": true; }; "boundaryCount": { "alias": "boundaryCount"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; "pageSize": "pageSizeChange"; "paginate": "paginate"; }, never, never, true, never>;
+}
+
+export { ColumnResize, NGX_PAGINATION_CONFIG, NGX_PAGINATION_CONFIG_DEFAULT, NGX_TABLE_CONFIG, NGX_TABLE_CONFIG_DEFAULT, NgxPagination, NgxTable, TableCell, defineFields, defineRenderers, providePagination, provideTable };
+export type { CellRendererComponent, CellTemplateContext, ColumnAlign, ColumnSizingConfig, LazyLoadEvent, NgxPaginationOptions, NgxTableOptions, PageEvent, PageState, PaginationLabel, PlainTableField, RenderedTableField, RendererExtraInputs, RendererRegistry, ResolvedTableOptions, SortDirection, SortMeta, TableCellFormatter, TableField, TableFieldBase, TableLabels };

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

@@ -173,6 +173,7 @@ declare class MSG {
     static success(title: string, text?: string, options?: IMessageOptions): ngx_kit_message.MessageOutput<any>;
     static warning(title: string, text?: string, options?: IMessageOptions): ngx_kit_message.MessageOutput<any>;
     static error(title: string, text?: string, options?: IMessageOptions): ngx_kit_message.MessageOutput<any>;
+    static question(title: string, text?: string, options?: IMessageOptions): ngx_kit_message.MessageOutput<any>;
     static loading(title: string, text?: string, options?: IMessageOptions): ngx_kit_message.MessageOutput<any>;
 }
 

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

@@ -12,6 +12,7 @@ interface NgxNotifyPayload {
     options: NgxNotifyOptions;
     onClose: EventEmitter<INotifyEnd>;
     onFinish: EventEmitter<INotifyEnd>;
+    close: () => void;
 }
 interface INotifyEnd {
     id: string;
@@ -129,6 +130,7 @@ declare class NgxNotifyService {
     configureContainer(position: NgxNotifyOptions['position'], containerClass: string): void;
     show(message: string, description?: string, type?: NgxNotifyType, options?: NgxNotifyOptions): NgxNotifyPayload;
     private _createAndShow;
+    private close;
     private removeNode;
     private removeEl;
     private _showNextIfPossible;

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

@@ -165,6 +165,8 @@ declare class SliderComponent implements OnInit, ControlValueAccessor, Validator
     static ɵcmp: i0.ɵɵComponentDeclaration<SliderComponent, "slider", never, { "step": { "alias": "step"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "background": { "alias": "background"; "required": false; }; "isBgTransparent": { "alias": "isBgTransparent"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
 }
 
+declare function mergeConfig<T>(base: T, override?: Partial<T>): T;
+
 declare function getOffsetPosition(evt: MouseEvent | TouchEvent, parent: HTMLElement): {
     x: number;
     y: number;
@@ -174,8 +176,6 @@ declare const WINDOW: InjectionToken<Window | null>;
 
 declare function randomStrnig(extraLength?: number, useNumeric?: boolean): string;
 
-declare function IsRtl(doc: Document): boolean;
-
 declare function makeConfetti(doc: Document, wrap: HTMLElement): void;
 
 declare class BrowserService {
@@ -187,6 +187,31 @@ declare class BrowserService {
     static ɵprov: i0.ɵɵInjectableDeclaration<BrowserService>;
 }
 
+type Direction = 'ltr' | 'rtl';
+/**
+ * جهت صفحه را به‌صورت خودکار و زنده تشخیص می‌دهد — بدون این‌که کاربرِ این
+ * سرویس مجبور باشد چیزی به آن بدهد. هر تغییری در attribute های dir/class
+ * روی <html> یا <body> (چه از طریق Angular، چه با یک تم‌سوییچر خارج از
+ * Angular) بلافاصله signal را آپدیت می‌کند.
+ *
+ * نکته: effect() اینجا جواب نمی‌دهد چون هیچ‌کدام از این مقادیر (attribute
+ * روی DOM) یک Signal نیستند؛ effect فقط به تغییر Signalها reactive است، نه
+ * به تغییرات دلخواه DOM. برای گوش‌دادن به تغییرات DOM باید از MutationObserver
+ * استفاده کرد و مقدار را دستی داخل یک Signal نوشت (که دقیقاً کاری است که
+ * این سرویس انجام می‌دهد).
+ */
+declare class DirectionService {
+    private readonly doc;
+    private readonly destroyRef;
+    private readonly _direction;
+    /** جهت جاری، به‌صورت Signal فقط-خواندنی. */
+    readonly direction: i0.Signal<Direction>;
+    readonly isRtl: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DirectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DirectionService>;
+}
+
 declare class OverlayRef<T> {
     private readonly dialogEl;
     private readonly teardownFn;
@@ -234,6 +259,7 @@ declare class OverlayService implements OnDestroy {
     private resizeRafPending;
     private readonly doc;
     private readonly abortController;
+    private readonly directionService;
     ngOnDestroy(): void;
     open<T>(options: OverlayOptions<T>): OverlayRef<T>;
     openTemplate(options: TemplateOptions): OverlayRef<any>;
@@ -274,5 +300,5 @@ interface OverlayInstance {
     cleanup: () => void;
 }
 
-export { BrowserService, DIALOG_OVERLAY_CLASSNAME, FOCUSABLE_SELECTOR, IsRtl, OverlayRef, OverlayService, RangeSliderComponent, SaturationComponent, SliderComponent, ValueModel, WINDOW, getOffsetPosition, makeConfetti, randomStrnig };
-export type { Alignment, BaseOverlayOptions, IPosition, IValue, OverlayInstance, OverlayOptions, Placement, Point, TemplateOptions };
+export { BrowserService, DIALOG_OVERLAY_CLASSNAME, DirectionService, FOCUSABLE_SELECTOR, OverlayRef, OverlayService, RangeSliderComponent, SaturationComponent, SliderComponent, ValueModel, WINDOW, getOffsetPosition, makeConfetti, mergeConfig, randomStrnig };
+export type { Alignment, BaseOverlayOptions, Direction, IPosition, IValue, OverlayInstance, OverlayOptions, Placement, Point, TemplateOptions };