ngx-kit 7.1.0 → 7.2.0

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

@@ -1,4 +1,4 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { TemplateRef, EventEmitter, InjectionToken, OnInit, OnDestroy, ElementRef, Renderer2 } from '@angular/core';
 
 interface IPosition {
@@ -81,8 +81,8 @@ declare class DragRef<T = unknown> {
     placeholder?: PlaceHolderRef;
     originDropList: DropListRef<T> | null;
     originIndex: number;
-    readonly isDragging: i0.WritableSignal<boolean>;
-    readonly position: i0.WritableSignal<IPosition>;
+    readonly isDragging: _angular_core.WritableSignal<boolean>;
+    readonly position: _angular_core.WritableSignal<IPosition>;
     private startPointer;
     private startRect;
     private lastPointer;
@@ -142,9 +142,9 @@ interface IResizableOutput {
 }
 
 declare class DragDropService {
-    readonly drags: i0.WritableSignal<readonly DragRef<unknown>[]>;
-    readonly dropLists: i0.WritableSignal<readonly DropListRef<any>[]>;
-    readonly activeDrag: i0.WritableSignal<DragRef<unknown> | null>;
+    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;
@@ -156,34 +156,34 @@ declare class DragDropService {
         x: number;
         y: number;
     }, current?: DropListRef | null): DropListRef | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DragDropService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DragDropService>;
+    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;
-    disabled: boolean;
+    readonly disabled: _angular_core.ModelSignal<boolean>;
     /** Element whose rect constrains the drag. Now actually enforced. */
-    boundary?: HTMLElement;
-    dragRootElement: string;
+    readonly boundary: _angular_core.InputSignal<HTMLElement | undefined>;
+    readonly dragRootElement: _angular_core.InputSignal<string>;
     /** CSS selector for a drag handle. When set, only pointerdowns inside it start a drag. */
-    dragHandle: string;
+    readonly dragHandle: _angular_core.InputSignal<string>;
     /** Restrict movement to a single axis. */
-    lockAxis: DragAxis;
+    readonly lockAxis: _angular_core.InputSignal<DragAxis>;
     /** Minimum pointer travel (px) before a drag starts, so clicks still register normally. */
-    dragThreshold: number;
+    readonly dragThreshold: _angular_core.InputSignal<number>;
     /** Pixel step used when dragging via the keyboard (arrow keys, focus required). */
-    keyboardStep: number;
+    readonly keyboardStep: _angular_core.InputSignal<number>;
     /** Auto-scroll the nearest scrollable ancestor while dragging near its edge. */
-    autoScroll: boolean;
+    readonly autoScroll: _angular_core.InputSignal<boolean>;
     set data(v: T);
-    readonly dragStart: EventEmitter<IPosition>;
-    readonly dragMove: EventEmitter<IPosition>;
-    readonly dragEnd: EventEmitter<IPosition>;
+    readonly dragStart: _angular_core.OutputEmitterRef<IPosition>;
+    readonly dragMove: _angular_core.OutputEmitterRef<IPosition>;
+    readonly dragEnd: _angular_core.OutputEmitterRef<IPosition>;
     readonly _ref: DragRef<T>;
-    readonly dragging: i0.WritableSignal<boolean>;
+    readonly dragging: _angular_core.WritableSignal<boolean>;
     private readonly doc;
     private readonly service;
     private readonly list;
@@ -209,30 +209,30 @@ declare class NgxDraggable<T = unknown> implements OnInit, OnDestroy {
     private keyDown;
     private isOnHandle;
     private isInteractive;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDraggable<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDraggable<any>, "[NgxDraggable],[ngxDraggable]", never, { "disabled": { "alias": "disabled"; "required": false; }; "boundary": { "alias": "boundary"; "required": false; }; "dragRootElement": { "alias": "dragRootElement"; "required": false; }; "dragHandle": { "alias": "dragHandle"; "required": false; }; "lockAxis": { "alias": "lockAxis"; "required": false; }; "dragThreshold": { "alias": "dragThreshold"; "required": false; }; "keyboardStep": { "alias": "keyboardStep"; "required": false; }; "autoScroll": { "alias": "autoScroll"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, { "dragStart": "dragStart"; "dragMove": "dragMove"; "dragEnd": "dragEnd"; }, never, never, true, never>;
+    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>;
 }
 
 declare class NgxResizable {
     private readonly el;
-    disabled: boolean;
-    minWidth: number;
-    minHeight: number;
-    maxWidth: number;
-    maxHeight: number;
-    directions: LogicalResizeDirection[];
-    grid?: number | {
+    disabled: _angular_core.ModelSignal<boolean>;
+    readonly minWidth: _angular_core.ModelSignal<number>;
+    readonly minHeight: _angular_core.ModelSignal<number>;
+    readonly maxWidth: _angular_core.ModelSignal<number>;
+    readonly maxHeight: _angular_core.ModelSignal<number>;
+    readonly directions: _angular_core.InputSignal<LogicalResizeDirection[]>;
+    readonly grid: _angular_core.InputSignal<number | {
         x: number;
         y: number;
-    };
+    } | undefined>;
     /** Element whose rect constrains the resize. Previously accepted nowhere on this directive. */
-    boundary?: HTMLElement;
+    readonly boundary: _angular_core.InputSignal<HTMLElement | undefined>;
     /** Pixel step used when resizing via the keyboard (arrow keys, focus required). */
-    keyboardStep: number;
-    readonly resizeStart: EventEmitter<IResizableOutput>;
-    readonly resizeMove: EventEmitter<IResizableOutput>;
-    readonly resizeEnd: EventEmitter<IResizableOutput>;
-    readonly resizing: i0.WritableSignal<boolean>;
+    readonly keyboardStep: _angular_core.InputSignal<number>;
+    readonly resizeStart: _angular_core.OutputEmitterRef<IResizableOutput>;
+    readonly resizeMove: _angular_core.OutputEmitterRef<IResizableOutput>;
+    readonly resizeEnd: _angular_core.OutputEmitterRef<IResizableOutput>;
+    readonly resizing: _angular_core.WritableSignal<boolean>;
     private direction;
     private start;
     private pointer;
@@ -253,8 +253,8 @@ declare class NgxResizable {
     private finish;
     private resolvedDirections;
     private hitDirection;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxResizable, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxResizable, "[NgxResizable],[ngxResizable]", never, { "disabled": { "alias": "disabled"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "directions": { "alias": "directions"; "required": false; }; "grid": { "alias": "grid"; "required": false; }; "boundary": { "alias": "boundary"; "required": false; }; "keyboardStep": { "alias": "keyboardStep"; "required": false; }; }, { "resizeStart": "resizeStart"; "resizeMove": "resizeMove"; "resizeEnd": "resizeEnd"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxResizable, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxResizable, "[NgxResizable],[ngxResizable]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "directions": { "alias": "directions"; "required": false; "isSignal": true; }; "grid": { "alias": "grid"; "required": false; "isSignal": true; }; "boundary": { "alias": "boundary"; "required": false; "isSignal": true; }; "keyboardStep": { "alias": "keyboardStep"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "minWidth": "minWidthChange"; "minHeight": "minHeightChange"; "maxWidth": "maxWidthChange"; "maxHeight": "maxHeightChange"; "resizeStart": "resizeStart"; "resizeMove": "resizeMove"; "resizeEnd": "resizeEnd"; }, never, never, true, never>;
 }
 
 declare const NGX_DROPLIST: InjectionToken<NgxDropList<any>>;
@@ -270,8 +270,8 @@ declare class NgxDropList<T = any> implements OnInit, OnDestroy {
     constructor(el: ElementRef<HTMLElement>);
     ngOnInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDropList<any>, never>;
-    static ɵdir: i0.ɵɵ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 ɵ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>;
 }
 
 declare const NGX_DROPLIST_GROUP: InjectionToken<NgxDropListGroup>;
@@ -279,8 +279,8 @@ declare const NGX_DROPLIST_GROUP: InjectionToken<NgxDropListGroup>;
 declare class NgxDropListGroup implements OnDestroy {
     readonly _ref: DropListGroupRef;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxDropListGroup, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxDropListGroup, "[NgxDropListGroup],[ngxDropListGroup]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxDropListGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxDropListGroup, "[NgxDropListGroup],[ngxDropListGroup]", never, {}, {}, never, never, true, never>;
 }
 
 declare const NGX_PLACEHOLDER: InjectionToken<PlaceHolderRef>;
@@ -289,8 +289,8 @@ declare class NgxPlaceholder {
     readonly _ref: PlaceHolderRef;
     private readonly list;
     constructor(tpl: TemplateRef<unknown>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxPlaceholder, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxPlaceholder, "[NgxPlaceholder],[ngxPlaceholder]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxPlaceholder, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxPlaceholder, "[NgxPlaceholder],[ngxPlaceholder]", never, {}, {}, never, never, true, never>;
 }
 
 /**

package/types/ngx-kit-form-field.d.ts

@@ -1,69 +1,72 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { AfterViewInit, ElementRef, InjectionToken } from '@angular/core';
 import * as ngx_kit_form_field from 'ngx-kit/form-field';
 
 declare class NgxFormField {
     protected readonly ref: ngx_kit_form_field.MgxFormFieldRef;
-    readonly label: i0.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
     /**
      * Forces the label to float even when the control is empty.
      * Similar to Material's floatLabel behavior.
      */
-    readonly float: i0.InputSignal<boolean>;
+    readonly float: _angular_core.InputSignal<boolean>;
     /**
      * Explicit state overrides are useful when the projected control
      * is managed by Angular Forms.
      */
-    readonly invalid: i0.InputSignal<boolean>;
-    readonly required: i0.InputSignal<boolean>;
-    readonly disabled: i0.InputSignal<boolean>;
-    readonly readonly: i0.InputSignal<boolean>;
-    readonly hintVisible: i0.Signal<boolean>;
-    readonly errorVisible: i0.Signal<boolean>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxFormField, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgxFormField, "ngx-form-field", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "float": { "alias": "float"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, ["[ngxPrefix],ngx-prefix", "[ngxInput],ngx-input", "[ngxSuffix],ngx-suffix", "[ngxHint],ngx-hint", "[ngxError],ngx-error"], true, never>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly hintVisible: _angular_core.Signal<boolean>;
+    readonly errorVisible: _angular_core.Signal<boolean>;
+    readonly value: _angular_core.ModelSignal<unknown>;
+    readonly errorMessages: _angular_core.InputSignal<string[] | undefined>;
+    readonly rows: _angular_core.InputSignal<number | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxFormField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgxFormField, "ngx-form-field", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "float": { "alias": "float"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["[ngxPrefix],ngx-prefix", "[ngxInput],ngx-input", "[ngxSuffix],ngx-suffix", "[ngxHint],ngx-hint", "[ngxError],ngx-error"], true, never>;
 }
 
 declare class NgxInput implements AfterViewInit {
     private readonly el;
     private readonly ref;
-    readonly hasValue: i0.WritableSignal<boolean>;
+    readonly hasValue: _angular_core.WritableSignal<boolean>;
     ngAfterViewInit(): void;
     protected onInput(): void;
     protected onChange(): void;
     protected onBlur(): void;
     private syncValue;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxInput, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxInput, "[ngxInput],ngx-input", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxInput, "[ngxInput],ngx-input", never, {}, {}, never, never, true, never>;
 }
 
 declare class NgxError {
     readonly el: ElementRef<HTMLElement>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxError, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxError, "[ngxError],ngx-error", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxError, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxError, "[ngxError],ngx-error", never, {}, {}, never, never, true, never>;
 }
 
 declare class NgxHint {
     readonly el: ElementRef<HTMLElement>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxHint, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxHint, "[ngxHint],ngx-hint", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxHint, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxHint, "[ngxHint],ngx-hint", never, {}, {}, never, never, true, never>;
 }
 
 declare class NgxPrefix {
     readonly el: ElementRef<HTMLElement>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxPrefix, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxPrefix, "[ngxPrefix],ngx-prefix", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxPrefix, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxPrefix, "[ngxPrefix],ngx-prefix", never, {}, {}, never, never, true, never>;
 }
 
 declare class NgxSuffix {
     readonly el: ElementRef<HTMLElement>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxSuffix, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxSuffix, "[ngxSuffix],ngx-suffix", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxSuffix, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgxSuffix, "[ngxSuffix],ngx-suffix", never, {}, {}, never, never, true, never>;
 }
 
 declare const MX_FORM_FIELD: InjectionToken<MgxFormFieldRef>;
 declare class MgxFormFieldRef {
-    readonly value: i0.WritableSignal<string>;
+    readonly value: _angular_core.WritableSignal<string>;
 }
 
 export { MX_FORM_FIELD, MgxFormFieldRef, NgxError, NgxFormField, NgxHint, NgxInput, NgxPrefix, NgxSuffix };

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

@@ -221,6 +221,44 @@ 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[];
+
 declare class BrowserService {
     private platformId;
     constructor(platformId: object);
@@ -342,5 +380,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, DIALOG_OVERLAY_CLASSNAME, DirectionService, FOCUSABLE_SELECTOR, OverlayRef, OverlayService, RangeSliderComponent, SaturationComponent, SliderComponent, ValueModel, WINDOW, filterTreeList, generateSequentialGuid, getOffsetPosition, makeConfetti, mergeConfig, mergeDeep, randomStrnig, startDragSession };
 export type { Alignment, BaseOverlayOptions, Direction, DragSessionCallbacks, IPosition, IValue, OverlayInstance, OverlayOptions, Placement, Point, TemplateOptions };