ngx-kit 7.1.0 → 7.3.0

package/types/ngx-kit-box-shadow.d.ts

@@ -1,103 +1,45 @@
-import * as i0 from '@angular/core';
-import { OnInit, AfterViewInit, OnDestroy, EventEmitter, ElementRef, ChangeDetectorRef, ViewContainerRef, Renderer2 } from '@angular/core';
-import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
-import { IPosition, BrowserService, OverlayService } from 'ngx-kit/shared';
+import * as _angular_core from '@angular/core';
+import { OnInit, AfterViewInit, ChangeDetectorRef } from '@angular/core';
+import { OverlayService } from 'ngx-kit/core';
 
-declare class NgxBoxShadowComponent implements OnInit, AfterViewInit, OnDestroy, ControlValueAccessor, Validator {
-    private cd;
-    theme: 'light' | 'dark' | 'auto';
-    set setTheme(val: 'light' | 'dark' | 'auto');
-    /**
-     * The maximum range of the box shadow.
-     * @default 25
-     */
-    maxRange: number;
-    change: EventEmitter<string>;
-    isDisabled: boolean;
-    isDragging: boolean;
-    value: IPosition;
-    x: number;
-    y: number;
-    blur: number;
-    spread: number;
+interface BoxShadow {
+    inset?: boolean;
+    xOffset: number;
+    yOffset: number;
+    blurRadius?: number;
+    spreadRadius?: number;
     color: string;
-    line: {
-        x1: number;
-        y1: number;
-        x2: number;
-        y2: number;
-    };
-    center: {
-        x: number;
-        y: number;
-    };
-    padRect?: DOMRect;
-    thumbRect?: DOMRect;
-    protected _onChange: (value: string) => void;
-    protected _onTouched: () => void;
-    _onValidateChange: () => void;
-    private stopDrag?;
-    pad: ElementRef<HTMLDivElement>;
-    thumb: ElementRef<HTMLDivElement>;
-    browserService: BrowserService;
-    constructor(cd: ChangeDetectorRef);
-    ngOnInit(): void;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    registerOnChange(fn: any): void;
-    registerOnTouched(fn: any): void;
-    setDisabledState(disabled: boolean): void;
-    registerOnValidatorChange(fn: () => void): void;
-    validate(control: AbstractControl): ValidationErrors | null;
-    writeValue(value: any): void;
-    dragStart(ev: MouseEvent | TouchEvent): void;
-    private updateRects;
-    private resetPosition;
-    onResize(): void;
-    private updatePosition;
-    setValueByPosition(thumbRec: DOMRect, padRec: DOMRect): void;
-    onChangeValue(): void;
-    private convertValueToPosition;
-    onChangeData(): void;
-    stopPropagation(ev: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxBoxShadowComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgxBoxShadowComponent, "ngx-box-shadow", never, { "setTheme": { "alias": "theme"; "required": false; }; "maxRange": { "alias": "maxRange"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
+    unit: string;
+    cssValue?: string;
 }
 
-declare class NgxInputBoxShadow implements OnDestroy, ControlValueAccessor, Validator {
-    private el;
-    private viewContainerRef;
-    private renderer;
-    private overlayService;
-    setInputBackground: boolean;
-    private pickerRef?;
-    value: string;
-    protected _onChange: (value: string) => void;
-    protected _onTouched: () => void;
-    _onValidateChange: () => void;
-    constructor(el: ElementRef, viewContainerRef: ViewContainerRef, renderer: Renderer2, overlayService: OverlayService);
-    onClick(ev: Event): void;
+declare class NgxShadowBox implements OnInit, AfterViewInit {
+    protected readonly maxRange: _angular_core.InputSignal<number>;
+    protected readonly shadowChange: _angular_core.OutputEmitterRef<string>;
+    selectedIndex: _angular_core.WritableSignal<number>;
+    shadows: _angular_core.WritableSignal<BoxShadow[]>;
+    result: string;
+    protected readonly doc: Document;
+    protected readonly win: Window | null;
+    protected readonly overlay: OverlayService;
+    protected readonly chdr: ChangeDetectorRef;
+    isDisabled: boolean;
+    onChange: (_: string) => void;
+    onTouched: () => void;
     registerOnChange(fn: any): void;
     registerOnTouched(fn: any): void;
-    setDisabledState(disabled: boolean): void;
-    registerOnValidatorChange(fn: () => void): void;
-    validate(control: AbstractControl): ValidationErrors | null;
-    ngOnDestroy(): void;
-    writeValue(value: any): void;
-    toggleColorPicker(): void;
-    destroyPicker(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxInputBoxShadow, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxInputBoxShadow, "[ngxInputBoxShadow]", never, { "setInputBackground": { "alias": "setInputBackground"; "required": false; }; }, {}, never, never, true, never>;
-}
-
-interface BoxShadowValue {
-    inset: boolean;
-    offsetX: number;
-    offsetY: number;
-    blurRadius: number;
-    spreadRadius: number;
-    color: string;
+    setDisabledState(isDisabled: boolean): void;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    writeValue(val: string): void;
+    addShadow(container: HTMLElement): void;
+    setShadow(el: HTMLElement, item: BoxShadow, index: number): void;
+    removeShadow(ev: Event, index: number): void;
+    private update;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxShadowBox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxShadowBox, "ngx-box-shadow", never, { "maxRange": { "alias": "maxRange"; "required": false; "isSignal": true; }; }, { "shadowChange": "shadowChange"; }, never, never, true, never>;
 }
 
-export { NgxBoxShadowComponent, NgxInputBoxShadow };
-export type { BoxShadowValue };
+export { NgxShadowBox };
+export type { BoxShadow };

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

@@ -1,7 +1,30 @@
-import * as i0 from '@angular/core';
-import { OnInit, OnDestroy, EventEmitter, ChangeDetectorRef, AfterViewInit, ElementRef, Renderer2, ViewContainerRef, PipeTransform } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, OnDestroy, ElementRef, EventEmitter, Renderer2, ViewContainerRef, PipeTransform } from '@angular/core';
 import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
-import { BrowserService, OverlayService } from 'ngx-kit/shared';
+import { OverlayService } from 'ngx-kit/core';
+
+declare enum ColorInspector {
+    Picker = 0,
+    RGB = 1,
+    HSL = 2,
+    CMYK = 3
+}
+
+type OutputType = 'CMYK' | 'HSL' | 'HSV' | 'RGB' | 'HEX';
+
+declare class NgxInputColorConfig {
+    /**
+     * show preset colors
+     * - It will not display preset colors in simple mode.
+     */
+    showPresets?: boolean;
+    presetColors?: string[];
+    /** Minifi UI  */
+    simpleMode?: boolean;
+    outputType?: OutputType;
+    defaultInspector?: ColorInspector;
+    useAlphaChannel?: boolean;
+}
 
 declare enum ColorFormats {
     HEX = 0,
@@ -63,8 +86,6 @@ declare class CMYK {
     k: number;
 }
 
-type OutputType = 'CMYK' | 'HSL' | 'HSV' | 'RGB' | 'HEX';
-
 type ColorInput = string | CMYK | HSLA | HSVA | RGBA | NgxColor;
 
 declare class NgxColor {
@@ -92,49 +113,32 @@ declare class NgxColor {
     removeAlphaChannel(): void;
 }
 
-declare enum ColorInspector {
-    Picker = 0,
-    RGB = 1,
-    HSL = 2,
-    CMYK = 3
-}
-
-declare class NgxInputColorComponent implements OnInit, OnDestroy, ControlValueAccessor, Validator {
-    private cd;
-    browserService: BrowserService;
-    theme: 'light' | 'dark';
-    set setTheme(val: 'light' | 'dark' | 'auto');
+declare class NgxInputColorComponent implements ControlValueAccessor, Validator {
+    protected readonly configs: NgxInputColorConfig;
     /** Minifi UI  */
-    simpleMode: boolean;
-    outputType: OutputType;
-    /**
-     * default inspectors
-     * - ColorInspector.Picker
-     * - ColorInspector.RGB
-     * - ColorInspector.HSL
-     *
-     * @alias defaultInspector
-     */
-    defaultInspector: ColorInspector;
-    useAlphaChannel: boolean;
-    set setUseAlphaChannel(val: boolean);
+    readonly simpleMode: _angular_core.InputSignal<boolean>;
+    readonly outputType: _angular_core.InputSignal<OutputType>;
+    readonly defaultInspector: _angular_core.ModelSignal<ColorInspector>;
+    readonly useAlphaChannel: _angular_core.InputSignal<boolean>;
+    readonly showPresets: _angular_core.InputSignal<boolean>;
+    readonly presetColors: _angular_core.InputSignal<string[]>;
     /** Emitted when the color value changes */
-    change: EventEmitter<string>;
+    colorChange: _angular_core.OutputEmitterRef<string>;
     /** @ignore */
     format: ColorFormats;
     /** @ignore */
     isDarkColor: boolean;
     /** @ignore */
-    rgbaColor: string;
+    rgbaColor: _angular_core.WritableSignal<string>;
     /** @ignore */
-    hexColor: string;
-    outputColor: string;
+    hexColor: _angular_core.WritableSignal<string>;
+    outputColor: _angular_core.WritableSignal<string>;
     /** @ignore */
-    name: string;
+    name: _angular_core.WritableSignal<string>;
     /** @ignore */
     isSupportedEyeDrop: boolean;
     /** @ignore */
-    color: NgxColor;
+    color: _angular_core.WritableSignal<NgxColor>;
     /** @ignore */
     isDisabled: boolean;
     /**@ignore */
@@ -143,11 +147,7 @@ declare class NgxInputColorComponent implements OnInit, OnDestroy, ControlValueA
     protected _onTouched: () => void;
     /**@ignore */
     private _onValidateChange;
-    constructor(cd: ChangeDetectorRef);
-    /** @ignore */
-    ngOnInit(): void;
-    /** @ignore */
-    ngOnDestroy(): void;
+    constructor();
     get ColorFormats(): typeof ColorFormats;
     get ColorInspector(): typeof ColorInspector;
     /** @ignore */
@@ -164,17 +164,16 @@ declare class NgxInputColorComponent implements OnInit, OnDestroy, ControlValueA
     writeValue(value: any): void;
     /** @ignore */
     openEyeDrop(): void;
+    selectColor(c: string): void;
     /**
      *  call from directive
     /* @ignore
      */
     initColor(c?: NgxColor): Promise<void>;
     /** @ignore */
-    stopPropagation(ev: Event): void;
-    /** @ignore */
     emitChange(): Promise<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxInputColorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgxInputColorComponent, "ngx-input-color", never, { "setTheme": { "alias": "theme"; "required": false; }; "simpleMode": { "alias": "simpleMode"; "required": false; }; "outputType": { "alias": "outputType"; "required": false; }; "defaultInspector": { "alias": "defaultInspector"; "required": false; }; "setUseAlphaChannel": { "alias": "useAlphaChannel"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxInputColorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxInputColorComponent, "ngx-input-color", never, { "simpleMode": { "alias": "simpleMode"; "required": false; "isSignal": true; }; "outputType": { "alias": "outputType"; "required": false; "isSignal": true; }; "defaultInspector": { "alias": "defaultInspector"; "required": false; "isSignal": true; }; "useAlphaChannel": { "alias": "useAlphaChannel"; "required": false; "isSignal": true; }; "showPresets": { "alias": "showPresets"; "required": false; "isSignal": true; }; "presetColors": { "alias": "presetColors"; "required": false; "isSignal": true; }; }, { "defaultInspector": "defaultInspectorChange"; "colorChange": "colorChange"; }, never, never, true, never>;
 }
 
 declare class NgxInputColor implements AfterViewInit, OnDestroy, ControlValueAccessor, Validator {
@@ -183,12 +182,16 @@ declare class NgxInputColor implements AfterViewInit, OnDestroy, ControlValueAcc
     private readonly viewContainerRef;
     private readonly overlayService;
     setInputBackgroundColor: boolean;
-    defaultInspector: ColorInspector;
-    simpleMode: boolean;
-    outputType: OutputType;
-    theme: 'light' | 'dark' | 'auto';
-    private useAlphaChannel;
-    set setUseAlphaChannel(value: boolean);
+    protected readonly configs: NgxInputColorConfig;
+    /** Minifi UI  */
+    readonly simpleMode: _angular_core.InputSignal<boolean>;
+    readonly outputType: _angular_core.InputSignal<OutputType>;
+    readonly defaultInspector: _angular_core.ModelSignal<ColorInspector>;
+    readonly useAlphaChannel: _angular_core.InputSignal<boolean>;
+    readonly showPresets: _angular_core.InputSignal<boolean>;
+    readonly presetColors: _angular_core.InputSignal<string[]>;
+    /** Emitted when the color value changes */
+    colorChange: _angular_core.OutputEmitterRef<string>;
     /**
      * Input target.
      *
@@ -246,7 +249,7 @@ declare class NgxInputColor implements AfterViewInit, OnDestroy, ControlValueAcc
      * must propagate through ControlValueAccessor.
      */
     private handleInputEvent;
-    private toggleColorPicker;
+    toggle(): void;
     private destroyColorPicker;
     /**
      * User-originated/custom-picker value.
@@ -269,8 +272,8 @@ declare class NgxInputColor implements AfterViewInit, OnDestroy, ControlValueAcc
     private syncHostBackground;
     private notifyValidatorChange;
     private isInputElement;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxInputColor, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxInputColor, "[ngxInputColor]", never, { "setInputBackgroundColor": { "alias": "setInputBackgroundColor"; "required": false; }; "defaultInspector": { "alias": "defaultInspector"; "required": false; }; "simpleMode": { "alias": "simpleMode"; "required": false; }; "outputType": { "alias": "outputType"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "setUseAlphaChannel": { "alias": "useAlphaChannel"; "required": false; }; "ngxInputColor": { "alias": "ngxInputColor"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxInputColor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxInputColor, "[ngxInputColor]", ["ngxInputColor"], { "setInputBackgroundColor": { "alias": "setInputBackgroundColor"; "required": false; }; "simpleMode": { "alias": "simpleMode"; "required": false; "isSignal": true; }; "outputType": { "alias": "outputType"; "required": false; "isSignal": true; }; "defaultInspector": { "alias": "defaultInspector"; "required": false; "isSignal": true; }; "useAlphaChannel": { "alias": "useAlphaChannel"; "required": false; "isSignal": true; }; "showPresets": { "alias": "showPresets"; "required": false; "isSignal": true; }; "presetColors": { "alias": "presetColors"; "required": false; "isSignal": true; }; "ngxInputColor": { "alias": "ngxInputColor"; "required": false; }; }, { "defaultInspector": "defaultInspectorChange"; "colorChange": "colorChange"; "change": "change"; }, never, never, true, never>;
 }
 
 declare class EnumToArrayPipe implements PipeTransform {
@@ -281,8 +284,8 @@ declare class EnumToArrayPipe implements PipeTransform {
      * C=3
      */
     transform(data: Object): string[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<EnumToArrayPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<EnumToArrayPipe, "enumToArray", true>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnumToArrayPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<EnumToArrayPipe, "enumToArray", true>;
 }
 declare class EnumToArrayStringValuePipe implements PipeTransform {
     /**
@@ -292,8 +295,8 @@ declare class EnumToArrayStringValuePipe implements PipeTransform {
      * C='C'
      */
     transform(data: Object, sort?: boolean): string[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<EnumToArrayStringValuePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<EnumToArrayStringValuePipe, "enumToArrayStringValue", true>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnumToArrayStringValuePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<EnumToArrayStringValuePipe, "enumToArrayStringValue", true>;
 }
 
 export { ColorInspector, EnumToArrayPipe, EnumToArrayStringValuePipe, NgxInputColor, NgxInputColorComponent };

package/types/{ngx-kit-shared.d.ts → ngx-kit-core.d.ts}

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { OnInit, OnDestroy, EventEmitter, ElementRef, ChangeDetectorRef, InjectionToken, ComponentRef, TemplateRef, Type, ViewContainerRef, ApplicationRef, EmbeddedViewRef } from '@angular/core';
+import { OnInit, OnDestroy, EventEmitter, ElementRef, ChangeDetectorRef, InjectionToken, ComponentRef, TemplateRef, Injector, Type, ViewContainerRef, ApplicationRef, EmbeddedViewRef } from '@angular/core';
 import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors, FormControl } from '@angular/forms';
 
 interface IValue {
@@ -166,8 +166,6 @@ declare class SliderComponent implements OnInit, OnDestroy, ControlValueAccessor
     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;
@@ -221,6 +219,80 @@ declare function generateSequentialGuid(): string;
  */
 declare function mergeDeep(...objects: any[]): any;
 
+/**
+ * Filters a hierarchical tree while preserving the branches
+ * that contain matching nodes.
+ *
+ * A node is included when:
+ * - the filter function matches the node itself, or
+ * - one or more of its descendants match.
+ *
+ * When only a descendant matches, a shallow copy of the parent
+ * is returned with only the matching descendants preserved.
+ *
+ * @param data The tree nodes to filter.
+ * @param filterFn Function used to determine whether a node matches.
+ * @param options Optional filtering configuration.
+ *
+ * @example
+ * ```ts
+ * const result = filterTreeList(
+ *   dataTree,
+ *   item =>
+ *     item.name.toLowerCase().includes(filter) ||
+ *     item.type.toLowerCase().includes(filter),
+ * );
+ * ```
+ *
+ * @example
+ * ```ts
+ * const result = filterTreeList(
+ *   data,
+ *   item => item.title.includes('angular'),
+ *   { childrenKeyName: 'items' },
+ * );
+ * ```
+ */
+declare function filterTreeList<T extends Record<string, any>>(data: readonly T[] | null | undefined, filterFn: (item: T) => boolean, options?: {
+    childrenKeyName?: string;
+}): T[];
+
+/**
+ * CSS named colors.
+ *
+ * Includes all standard CSS color keywords plus:
+ * - transparent
+ * - currentcolor
+ */
+declare const CSS_COLOR_NAMES: Record<string, string>;
+/**
+ * Extract all CSS colors from an arbitrary CSS string.
+ *
+ * Supports:
+ * - Hex: #fff, #ffff, #ffffff, #ffffffff
+ * - rgb()
+ * - rgba()
+ * - hsl()
+ * - hsla()
+ * - hwb()
+ * - lab()
+ * - lch()
+ * - oklab()
+ * - oklch()
+ * - color()
+ * - CSS named colors
+ * - transparent
+ * - currentcolor
+ *
+ * Works with values such as:
+ *
+ *   box-shadow: 0 0 10px red, 0 0 20px #00ff00;
+ *   linear-gradient(red, rgba(0, 0, 0, .5));
+ *   radial-gradient(circle, blue 0%, transparent 100%);
+ *   conic-gradient(from 90deg, yellow, #ff0000);
+ */
+declare function extractCssColors(value: string | null | undefined): string[];
+
 declare class BrowserService {
     private platformId;
     constructor(platformId: object);
@@ -256,13 +328,14 @@ declare class DirectionService {
 }
 
 declare class OverlayRef<T> {
-    private readonly dialogEl;
-    private readonly teardownFn;
+    private readonly element;
+    private readonly closeFn;
     readonly componentRef?: ComponentRef<T> | undefined;
-    readonly templateRef?: TemplateRef<T> | undefined;
-    constructor(dialogEl: HTMLDialogElement, teardownFn: () => void, componentRef?: ComponentRef<T> | undefined, templateRef?: TemplateRef<T> | undefined);
+    readonly template?: TemplateRef<unknown> | undefined;
+    constructor(element: HTMLElement | null, closeFn: () => void, componentRef?: ComponentRef<T> | undefined, template?: TemplateRef<unknown> | undefined);
     close(): void;
-    get nativeElement(): HTMLElement;
+    get nativeElement(): HTMLElement | null;
+    static noop<T>(): OverlayRef<T>;
 }
 
 /**
@@ -272,59 +345,146 @@ interface Point {
     x: number;
     y: number;
 }
-type Placement = 'top' | 'bottom' | 'auto';
+/**
+ * instead of being placed above/below a (possibly absent) anchor.
+ */
+type Placement = 'top' | 'bottom' | 'center' | 'auto';
 type Alignment = 'start' | 'center' | 'end';
-interface BaseOverlayOptions<T> {
-    anchor: HTMLElement;
+interface BaseOverlayOptions<T = any> {
+    /**
+     * Element the overlay is positioned
+     */
+    anchor?: HTMLElement;
     /** pointer for context menu */
     point?: Point;
     placement?: Placement;
     alignment?: Alignment;
     margin?: number;
+    /**
+     * Whether to render this overlay using the native Popover API (top-layer
+     * rendering, escapes clipping/stacking-context issues of ancestors).
+     * Falls back automatically to a manual z-index based overlay when the
+     * browser doesn't support the Popover API. Defaults to `true`.
+     */
+    usePopover?: boolean;
+    /**
+     * Parent injector used when creating the overlay's component. Lets callers
+     * (e.g. a dialog service) provide their own tokens - such as data or a
+     * reference back to the overlay - to the created component and everything
+     * it projects. Defaults to the injector of `viewContainerRef` (or, when
+     * `viewContainerRef` is omitted, the root environment injector).
+     */
+    injector?: Injector;
+    /** Close this overlay when Escape is pressed while it's the topmost overlay. Default: true. */
+    closeOnEscape?: boolean;
+    /** Close this overlay on a click outside its panel and anchor. Default: true. */
+    closeOnOutsideClick?: boolean;
+    /**
+     * Synchronous guard consulted before Escape/outside-click would close the
+     * overlay. Return `false` to block the dismissal (e.g. "unsaved changes").
+     * Does NOT affect programmatic `close()` calls.
+     */
+    canClose?: () => boolean;
+    /** Move focus into the overlay when it opens. Default: true. */
+    autoFocus?: boolean;
+    /** Restore focus to the previously focused element when the overlay closes. Default: true. */
+    restoreFocus?: boolean;
+    /** Prevent the page behind the overlay from scrolling while it's open. Default: false. */
+    lockBodyScroll?: boolean;
+    /** Extra class(es) applied to the backdrop element. */
+    backdropClass?: string | string[];
+    /** Extra class(es) applied to the overlay panel element. */
+    panelClass?: string | string[];
+    /** `role` attribute for the overlay panel. Default: 'dialog'. */
+    role?: string;
+    /** Whether to set `aria-modal="true"` on the overlay panel. Default: true. */
+    ariaModal?: boolean;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
     configure?: (instance: T, ref: OverlayRef<T>) => void;
     onClosed?: () => void;
 }
 interface OverlayOptions<T> extends BaseOverlayOptions<T> {
     component: Type<T>;
-    viewContainerRef: ViewContainerRef;
+    /**
+     * Optional. When provided, the component is created through this
+     * ViewContainerRef (inheriting its injector/change-detection context by
+     * default - override with `injector`). When omitted, the component is
+     * created and attached directly to the ApplicationRef, which is what lets
+     * services with no template context (e.g. a global dialog service) open
+     * overlays without needing a host ViewContainerRef.
+     */
+    viewContainerRef?: ViewContainerRef;
 }
 interface TemplateOptions extends BaseOverlayOptions<any> {
     template: TemplateRef<any>;
-    appRef: ApplicationRef;
+    /** Falls back to the ApplicationRef injected internally by OverlayService when omitted. */
+    appRef?: ApplicationRef;
 }
 
-declare const FOCUSABLE_SELECTOR = "button, [href], input, select, textarea, [tabindex]:not([tabindex=\"-1\"])";
+declare const FOCUSABLE_SELECTOR: string;
 declare const DIALOG_OVERLAY_CLASSNAME = "ngx-ui-overlay";
-declare class OverlayService implements OnDestroy {
-    private readonly overlayStacks;
-    private listenersAttached;
-    private resizeRafPending;
-    private readonly doc;
-    private readonly abortController;
+declare const OVERLAY_HOST_CLASSNAME = "ngx-ui-overlay-host";
+declare class OverlayService {
+    private readonly document;
     private readonly directionService;
-    ngOnDestroy(): void;
+    private readonly platformId;
+    private readonly applicationRef;
+    private readonly environmentInjector;
+    private readonly overlayStack;
+    private globalListenersAttached;
+    private layoutRaf;
+    private bodyScrollLockCount;
+    private previousBodyOverflow;
+    private previousBodyPaddingRight;
+    private get isBrowser();
+    /** Number of overlays currently open. */
+    get openCount(): number;
     open<T>(options: OverlayOptions<T>): OverlayRef<T>;
     openTemplate(options: TemplateOptions): OverlayRef<any>;
     closeAll(): void;
-    private resolvePlacementConfig;
-    private createDialogElement;
-    private scheduleInitialLayout;
+    private createComponentInstance;
+    private createTemplateInstance;
+    private pushInstance;
+    private createHostElement;
+    private createBackdropElement;
+    private createOverlayElement;
+    private addClasses;
+    private renderHost;
     private destroyInstance;
+    private resolveUsePopover;
+    private showHostPopover;
+    private hideHostPopover;
+    private supportsPopover;
+    private lockBodyScroll;
+    private unlockBodyScroll;
     private attachGlobalListeners;
-    private readonly onGlobalKeyDown;
-    private readonly onGlobalResize;
-    private readonly onGlobalPointerEvent;
-    private handleClickOnBackdrop;
-    private getLastDialog;
-    private repositionAll;
-    private positionDialog;
+    private detachGlobalListeners;
+    private readonly onDocumentKeydown;
+    private readonly onDocumentClick;
+    private readonly onDocumentContextMenu;
+    private readonly onDocumentScroll;
+    private readonly onWindowResize;
+    private scheduleReposition;
+    private scheduleInitialLayout;
+    private focusInitialElement;
+    private trapFocus;
+    private restoreFocus;
+    private getActiveElement;
+    private positionOverlay;
+    private getAnchorRect;
+    private resolvePlacementConfig;
+    private getLastInstance;
+    private requestAnimationFrame;
+    private cancelAnimationFrame;
     static ɵfac: i0.ɵɵFactoryDeclaration<OverlayService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<OverlayService>;
 }
 
 interface PlacementConfig {
-    placement: 'top' | 'bottom' | 'auto';
-    alignment: 'start' | 'center' | 'end';
+    placement: Placement;
+    alignment: Alignment;
     margin: number;
 }
 
@@ -342,5 +502,5 @@ interface OverlayInstance {
     cleanup: () => void;
 }
 
-export { BrowserService, DIALOG_OVERLAY_CLASSNAME, DirectionService, FOCUSABLE_SELECTOR, OverlayRef, OverlayService, RangeSliderComponent, SaturationComponent, SliderComponent, ValueModel, WINDOW, generateSequentialGuid, getOffsetPosition, makeConfetti, mergeConfig, mergeDeep, randomStrnig, startDragSession };
+export { BrowserService, CSS_COLOR_NAMES, DIALOG_OVERLAY_CLASSNAME, DirectionService, FOCUSABLE_SELECTOR, OVERLAY_HOST_CLASSNAME, OverlayRef, OverlayService, RangeSliderComponent, SaturationComponent, SliderComponent, ValueModel, WINDOW, extractCssColors, filterTreeList, generateSequentialGuid, getOffsetPosition, makeConfetti, mergeDeep, randomStrnig, startDragSession };
 export type { Alignment, BaseOverlayOptions, Direction, DragSessionCallbacks, IPosition, IValue, OverlayInstance, OverlayOptions, Placement, Point, TemplateOptions };

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

@@ -1,6 +1,6 @@
 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_core from 'ngx-kit/core';
 import * as ngx_kit_data_table from 'ngx-kit/data-table';
 
 type SortDirection = 'asc' | 'desc';
@@ -284,7 +284,7 @@ declare class NgxTable<T extends object> implements OnInit, AfterContentInit {
     protected readonly resolvedMultiSort: _angular_core.Signal<boolean>;
     private readonly directionService;
     private readonly destroyRef;
-    protected readonly resolvedDirection: _angular_core.Signal<ngx_kit_shared.Direction>;
+    protected readonly resolvedDirection: _angular_core.Signal<ngx_kit_core.Direction>;
     constructor();
     ngOnInit(): void;
     ngAfterContentInit(): void;