ngx-register-base 1.3.1 → 1.3.2

package/lib/components/inputs/param-date-time-range/param-date-time-range.component.d.ts

@@ -0,0 +1,28 @@
+import { PrizmDateTimeRange, PrizmDay, PrizmDayLike, PrizmTimeMode } from '@prizm-ui/components';
+import { ParamDateBase } from '../../../core/param/param-date-base';
+import { FormatterSavedValueType, ParserSavedValueType } from '../../../types/params.types';
+import * as i0 from "@angular/core";
+export type InputDateTimeRangeSaveValue = {
+    from: string;
+    to: string;
+} | null;
+export declare class ParamDateTimeRangeComponent extends ParamDateBase<PrizmDateTimeRange | null, InputDateTimeRangeSaveValue> {
+    placeholder: import("@angular/core").InputSignal<string>;
+    min: PrizmDay | undefined;
+    max: PrizmDay | undefined;
+    timeMode: PrizmTimeMode;
+    maxLength: PrizmDayLike | null;
+    set formatSavedValue(formatter: FormatterSavedValueType<PrizmDateTimeRange | null, InputDateTimeRangeSaveValue> | undefined);
+    set parseSavedValue(parser: ParserSavedValueType<InputDateTimeRangeSaveValue, PrizmDateTimeRange | null> | undefined);
+    protected formatterSavedValue: (range: PrizmDateTimeRange | null) => InputDateTimeRangeSaveValue;
+    protected parserSavedValue: (value: InputDateTimeRangeSaveValue) => PrizmDateTimeRange | null;
+    private _defaultFormatterSaveValue;
+    private _defaultParserSaveValue;
+    protected onInit(): void;
+    private _subscribeOnTimeZoneChanges;
+    protected get from(): Date | null;
+    protected get to(): Date | null;
+    private _getDateFromRange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamDateTimeRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamDateTimeRangeComponent, "sproc-param-date-time-range", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "timeMode": { "alias": "timeMode"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "formatSavedValue": { "alias": "formatSavedValue"; "required": false; }; "parseSavedValue": { "alias": "parseSavedValue"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/components/inputs/param-month/param-month.component.d.ts

@@ -0,0 +1,18 @@
+import { ParamDateBase } from '../../../core/param/param-date-base';
+import { PrizmMonth } from '@prizm-ui/components';
+import { FormatterSavedValueType, ParserSavedValueType } from '../../../types/params.types';
+import * as i0 from "@angular/core";
+export type InputMonthSavedValue = string | null;
+export declare class ParamMonthComponent extends ParamDateBase<PrizmMonth | null, InputMonthSavedValue> {
+    placeholder: import("@angular/core").InputSignal<string>;
+    set formatSavedValue(formatter: FormatterSavedValueType<PrizmMonth | null, InputMonthSavedValue> | undefined);
+    set parseSavedValue(parser: ParserSavedValueType<InputMonthSavedValue, PrizmMonth | null> | undefined);
+    buildShowedValue: import("@angular/core").InputSignal<(value: PrizmMonth | null) => string>;
+    protected formatterSavedValue: (month: PrizmMonth | null) => InputMonthSavedValue;
+    protected parserSavedValue: (value: InputMonthSavedValue) => PrizmMonth | null;
+    private _defaultFormatterSaveValue;
+    private _defaultParserSaveValue;
+    private _formatMonth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamMonthComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamMonthComponent, "sproc-param-month", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "formatSavedValue": { "alias": "formatSavedValue"; "required": false; }; "parseSavedValue": { "alias": "parseSavedValue"; "required": false; }; "buildShowedValue": { "alias": "buildShowedValue"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}

package/lib/components/inputs/param-month-range/param-month-range.component.d.ts

@@ -0,0 +1,21 @@
+import { PrizmMonthRange } from '@prizm-ui/components';
+import { ParamDateBase } from '../../../core/param/param-date-base';
+import { FormatterSavedValueType, ParserSavedValueType } from '../../../types/params.types';
+import * as i0 from "@angular/core";
+export type InputMonthRangeSavedValue = {
+    from: string;
+    to: string;
+} | null;
+export declare class ParamMonthRangeComponent extends ParamDateBase<PrizmMonthRange | null, InputMonthRangeSavedValue> {
+    placeholder: import("@angular/core").InputSignal<string>;
+    set formatSavedValue(formatter: FormatterSavedValueType<PrizmMonthRange | null, InputMonthRangeSavedValue> | undefined);
+    set parseSavedValue(parser: ParserSavedValueType<InputMonthRangeSavedValue, PrizmMonthRange | null> | undefined);
+    buildShowedValue: import("@angular/core").InputSignal<(range: PrizmMonthRange | null) => string>;
+    protected formatterSavedValue: (range: PrizmMonthRange | null) => InputMonthRangeSavedValue;
+    protected parserSavedValue: (value: InputMonthRangeSavedValue) => PrizmMonthRange | null;
+    private _defaultFormatterSaveValue;
+    private _defaultParserSaveValue;
+    private _formatMonth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamMonthRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamMonthRangeComponent, "sproc-param-month-range", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "formatSavedValue": { "alias": "formatSavedValue"; "required": false; }; "parseSavedValue": { "alias": "parseSavedValue"; "required": false; }; "buildShowedValue": { "alias": "buildShowedValue"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}

package/lib/components/inputs/param-multi-select/param-multi-select.component.d.ts

@@ -0,0 +1,46 @@
+import { Injector, OnDestroy } from '@angular/core';
+import { PrizmMultiSelectSearchMatcher } from '@prizm-ui/components';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { TuiContext, TuiIdentityMatcher, TuiStringHandler } from '@taiga-ui/cdk';
+import { IFilterSelectValue } from '../../../types/params.types';
+import { ParamSelectBase } from '../../../core/param/param-select-base';
+import * as i0 from "@angular/core";
+export declare class ParamMultiSelectComponent extends ParamSelectBase<IFilterSelectValue[], IFilterSelectValue[]> implements OnDestroy {
+    private document;
+    readonly placeholder: import("@angular/core").InputSignal<string>;
+    readonly itemSelectAll: import("@angular/core").InputSignal<boolean>;
+    readonly searchMatcher: import("@angular/core").InputSignal<PrizmMultiSelectSearchMatcher<IFilterSelectValue>>;
+    readonly shortPickedLength: import("@angular/core").InputSignal<boolean>;
+    readonly stringify: import("@angular/core").InputSignal<TuiStringHandler<IFilterSelectValue | TuiContext<IFilterSelectValue>>>;
+    readonly identityMatcher: import("@angular/core").InputSignal<TuiIdentityMatcher<IFilterSelectValue>>;
+    readonly buildShowedValue: import("@angular/core").InputSignal<(values: IFilterSelectValue[]) => string>;
+    readonly onSelect: import("@angular/core").OutputEmitterRef<IFilterSelectValue[]>;
+    protected readonly selectAllItem: IFilterSelectValue;
+    protected onCancelButtonSubscription: Subscription;
+    protected searchValue: string;
+    protected readonly onSearch$: BehaviorSubject<string>;
+    private onSearchSubscription;
+    private cachedString;
+    private onClearButtonSubscription;
+    choosedHint: string;
+    constructor(injector: Injector, document: Document);
+    onInit(): void;
+    private _subscribeOnSearch;
+    afterViewInit(): void;
+    private _observeFetchItems;
+    private _subscribeOnMetaChanges;
+    private _subscribeOnValueControl;
+    ngOnDestroy(): void;
+    protected fetchItems(searchValue?: string): void;
+    private _subscribeOnClearButton;
+    private _getSelectedItemIDs;
+    private _buildSelectedItemIdsWhere;
+    private _handleResults;
+    private _updateControlValues;
+    private _getNameFromField;
+    private _getNameFromDeepField;
+    protected onSearch(value: string | null): void;
+    protected getListLength(list: IFilterSelectValue[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamMultiSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamMultiSelectComponent, "sproc-param-multi-select", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "itemSelectAll": { "alias": "itemSelectAll"; "required": false; "isSignal": true; }; "searchMatcher": { "alias": "searchMatcher"; "required": false; "isSignal": true; }; "shortPickedLength": { "alias": "shortPickedLength"; "required": false; "isSignal": true; }; "stringify": { "alias": "stringify"; "required": false; "isSignal": true; }; "identityMatcher": { "alias": "identityMatcher"; "required": false; "isSignal": true; }; "buildShowedValue": { "alias": "buildShowedValue"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
+}

package/lib/components/inputs/param-select/param-select.component.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { TuiStringMatcher } from '@taiga-ui/cdk';
+import { ParamSelectBase } from '../../../core/param/param-select-base';
+import { IFilterSelectValue } from '../../../types/params.types';
+import * as i0 from "@angular/core";
+export declare class ParamSelectComponent extends ParamSelectBase<IFilterSelectValue | null, IFilterSelectValue | null> implements OnDestroy {
+    placeholder: import("@angular/core").InputSignal<string>;
+    readonly stringify: import("@angular/core").InputSignal<(item: IFilterSelectValue) => string>;
+    readonly identityMatcher: import("@angular/core").InputSignal<(a: IFilterSelectValue, b: IFilterSelectValue) => boolean>;
+    readonly matcher: import("@angular/core").InputSignal<TuiStringMatcher<IFilterSelectValue>>;
+    buildShowedValue: import("@angular/core").InputSignal<(value: IFilterSelectValue | null) => string>;
+    strict: import("@angular/core").InputSignal<boolean>;
+    onSelect: EventEmitter<IFilterSelectValue>;
+    protected readonly search$: BehaviorSubject<string | undefined>;
+    afterViewInit(): void;
+    ngOnDestroy(): void;
+    private _subscribeOnSearch;
+    private _observeFetchItems;
+    private _observeValueFill;
+    private _observeEmptyValue;
+    private _observeValueFetch;
+    private _getIdFromValue;
+    private _subscribeOnMetaChanges;
+    protected fetchItems(searchValue?: string): void;
+    private _getSelectedItemIDs;
+    private _buildSelectedItemIdsWhere;
+    private _handleResults;
+    private _getNameFromField;
+    private _getNameFromDeepField;
+    private _updateControlValues;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamSelectComponent, "sproc-param-select", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "stringify": { "alias": "stringify"; "required": false; "isSignal": true; }; "identityMatcher": { "alias": "identityMatcher"; "required": false; "isSignal": true; }; "matcher": { "alias": "matcher"; "required": false; "isSignal": true; }; "buildShowedValue": { "alias": "buildShowedValue"; "required": false; "isSignal": true; }; "strict": { "alias": "strict"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
+}

package/lib/components/inputs/param-switcher/param-switcher.component.d.ts

@@ -0,0 +1,8 @@
+import { PrizmSwitcherItem } from '@prizm-ui/components';
+import { ParamBase } from '../../../core';
+import * as i0 from "@angular/core";
+export declare class ParamSwitcherComponent extends ParamBase<number, number> {
+    switchers: PrizmSwitcherItem[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamSwitcherComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamSwitcherComponent, "sproc-param-switcher", never, { "switchers": { "alias": "switchers"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/components/inputs/param-switcher-date-time-range/consts/param-switcher-date-time-range.consts.d.ts

@@ -0,0 +1,2 @@
+import { PrizmSwitcherItem } from '@prizm-ui/components';
+export declare const SwitcherItems: PrizmSwitcherItem[];

package/lib/components/inputs/param-switcher-date-time-range/param-switcher-date-time-range.component.d.ts

@@ -0,0 +1,19 @@
+import { FormControl } from '@angular/forms';
+import { ESwitcherValue } from './types/param-switcher-date-time-range.types';
+import { ParamDateTimeRangeComponent } from '../param-date-time-range/param-date-time-range.component';
+import * as i0 from "@angular/core";
+export declare class ParamSwitcherDateTimeRangeComponent extends ParamDateTimeRangeComponent {
+    protected switcherControl: FormControl<ESwitcherValue | null>;
+    protected switchers: import("@prizm-ui/components").PrizmSwitcherItem<import("@prizm-ui/components").PrizmSwitcherId>[];
+    onInit(): void;
+    afterViewInit(): void;
+    private _subscribeOnSwitcher;
+    private _calcMonthRange;
+    private _calcFirstQuarterRange;
+    private _calcSecondQuarterRange;
+    private _calcThirdQuarterRange;
+    private _calcFourthQuarterRange;
+    private _calcYearRange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamSwitcherDateTimeRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamSwitcherDateTimeRangeComponent, "sproc-param-switcher-date-time-range", never, {}, {}, never, never, false, never>;
+}

package/lib/components/inputs/param-switcher-date-time-range/types/param-switcher-date-time-range.types.d.ts

@@ -0,0 +1,8 @@
+export declare enum ESwitcherValue {
+    MONTH = 0,
+    FIRST = 1,
+    SECOND = 2,
+    THIRD = 3,
+    FOURTH = 4,
+    YEAR = 5
+}

package/lib/components/inputs/param-text/param-text.component.d.ts

@@ -0,0 +1,10 @@
+import { MaskitoOptions } from '@maskito/core';
+import { ParamTextBase } from '../../../core/param';
+import * as i0 from "@angular/core";
+export declare class ParamTextComponent extends ParamTextBase {
+    maskOptions: import("@angular/core").InputSignal<MaskitoOptions | null>;
+    /** сообщение об ошибке для текстового поля */
+    errorMessage: import("@angular/core").InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamTextComponent, "sproc-param-text", never, { "maskOptions": { "alias": "maskOptions"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/inputs/param-textarea/param-textarea.component.d.ts

@@ -0,0 +1,10 @@
+import { ParamTextBase } from '../../../core/param';
+import * as i0 from "@angular/core";
+export declare class ParamTextareaComponent extends ParamTextBase {
+    /** Минимальное кол-во строк в инпуте */
+    min: import("@angular/core").InputSignal<number>;
+    /** Максимальное кол-во строк в инпуте */
+    max: import("@angular/core").InputSignal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamTextareaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamTextareaComponent, "sproc-param-textarea", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/inputs/param-toggle/param-toggle.component.d.ts

@@ -0,0 +1,9 @@
+import { ParamBase } from '../../../core/param/param-base';
+import { TuiSizeS } from '@taiga-ui/core';
+import * as i0 from "@angular/core";
+export declare class ParamToggleComponent extends ParamBase<boolean, boolean> {
+    buildShowedValue: import("@angular/core").InputSignal<(value: boolean) => string>;
+    size: import("@angular/core").InputSignal<TuiSizeS>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamToggleComponent, "sproc-param-toggle", never, { "buildShowedValue": { "alias": "buildShowedValue"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}

package/lib/components/inputs/param-tree/consts/param-tree.consts.d.ts

@@ -0,0 +1,7 @@
+import { ParamTreeService } from '../services/param-tree.service';
+import { ITreeNode } from '../types/param-tree.types';
+export declare const TREE_LOADING_NODE: ITreeNode;
+export declare const DEBOUNCE_TIME_FOR_SYNC_NEXT_VALUES = 250;
+export declare const notEmpty: (children?: ITreeNode[]) => boolean;
+export declare function treeNodesFlatten<T>(node: ITreeNode<T>, service: ParamTreeService<T>): ITreeNode<T>[];
+export declare function updatesCheckedNodesEqual<T>(prev: ITreeNode<T>[] | undefined, curr: ITreeNode<T>[] | undefined, service: ParamTreeService<T>): boolean;

package/lib/components/inputs/param-tree/param-tree.component.d.ts

@@ -0,0 +1,41 @@
+import { TemplateRef } from '@angular/core';
+import { ChildrenHandlerType, ITreeNode } from './types/param-tree.types';
+import * as i0 from "@angular/core";
+/** Компонент иерархического списка */
+export declare class ParamTreeComponent<T> {
+    /**
+     * Режим выбора нескольких значений
+     *
+     * @default Выбор единственного узла */
+    multi: import("@angular/core").InputSignal<boolean>;
+    /** Задать выбранные узлы */
+    checkedNodes: import("@angular/core").InputSignal<ITreeNode<T>[]>;
+    /** Кастомный шаблон узла */
+    nodeTemplate: import("@angular/core").InputSignal<TemplateRef<any> | null>;
+    /** Выбранные узлы верхнего уровня */
+    readonly selectedNodesChange: import("@angular/core").OutputEmitterRef<ITreeNode<T>[]>;
+    private readonly _treeService;
+    private readonly _dr;
+    protected readonly defaultNodeOpenedState: import("@angular/core").Signal<boolean | undefined>;
+    protected readonly openedNodesState: import("@angular/core").WritableSignal<Map<ITreeNode<T>, boolean>>;
+    protected readonly checkedNodesState: import("@angular/core").WritableSignal<Map<ITreeNode<T>, boolean | null>>;
+    private readonly _lastCheckedNode;
+    private readonly updatesCheckedNodes;
+    protected readonly treeNodes$: import("rxjs").Observable<ITreeNode<T>[]>;
+    protected readonly TREE_LOADER: ITreeNode<any>;
+    protected readonly childrenHandler: ChildrenHandlerType<T>;
+    constructor();
+    protected getValue(currentNode: ITreeNode<T>, state: Map<ITreeNode<T>, boolean | null>): boolean | null;
+    private _isSelectedMulti;
+    private _isSelectedSingle;
+    private _isDeepParent;
+    private _isDeepChild;
+    protected onToggle(currentNode: ITreeNode<T>): void;
+    protected onChecked: (currentNode: ITreeNode<T>, check: boolean) => void;
+    private _updateCheckedNodes;
+    private _findFullySelectedNodes;
+    private _calcCheckedStateNodes;
+    private _tryToSetNodesRecursive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamTreeComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamTreeComponent<any>, "sproc-param-tree", never, { "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "checkedNodes": { "alias": "checkedNodes"; "required": false; "isSignal": true; }; "nodeTemplate": { "alias": "nodeTemplate"; "required": false; "isSignal": true; }; }, { "selectedNodesChange": "selectedNodesChange"; }, never, never, true, never>;
+}

package/lib/components/inputs/param-tree/services/param-tree.service.d.ts

@@ -0,0 +1,37 @@
+import { Observable } from 'rxjs';
+import { ITreeNode } from '../types/param-tree.types';
+import * as i0 from "@angular/core";
+export declare class ParamTreeService<T> {
+    private readonly _loading;
+    private readonly _start$;
+    private readonly _loader;
+    private readonly _destroyRef;
+    private readonly _loaderNode$;
+    private readonly _defaultNodeOpenedState$;
+    private readonly _lastCheckedNode$;
+    private readonly _load$;
+    private readonly _parentChildrenMap;
+    private readonly _nodes$;
+    private readonly _loadedChildren$;
+    readonly defaultNodeOpenedState$: Observable<boolean | undefined>;
+    readonly lastCheckedNode$: Observable<ITreeNode<T> | null>;
+    readonly loaderNode$: Observable<ITreeNode<T>>;
+    readonly openedNodesState: import("@angular/core").WritableSignal<Map<ITreeNode<T>, boolean>>;
+    readonly checkedNodesState: import("@angular/core").WritableSignal<Map<ITreeNode<T>, boolean | null>>;
+    private _firstLevelNodes;
+    private _firstLevelNodesLoaded;
+    readonly nodes$: Observable<ITreeNode<T>[]>;
+    constructor();
+    private _recursiveLoad;
+    loadFirstLevelNodes(node: ITreeNode<T>, opened?: boolean): void;
+    private _load;
+    loadChildren(node: ITreeNode<T>): Observable<ITreeNode<T>[]>;
+    getChildren(node: ITreeNode<T>): ITreeNode<T>[];
+    hasChildren(node: ITreeNode<T>): boolean;
+    getTopLevelNodes(): ITreeNode<T>[];
+    setLoaderNode(loaderNode: ITreeNode<T>, defaultNodeOpenedState?: boolean): void;
+    setLastCheckedNode(node: ITreeNode<T> | null): void;
+    equals(node1: ITreeNode<T>, node2: ITreeNode<T>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamTreeService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ParamTreeService<any>>;
+}

package/lib/components/inputs/param-tree/services/sync-tree-loader.service.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+import { ITreeNode, SmaTreeLoader } from '../types/param-tree.types';
+import * as i0 from "@angular/core";
+export declare class SyncTreeLoaderService<T> implements SmaTreeLoader<ITreeNode<T>> {
+    loadChildren({ children }: ITreeNode<T>): Observable<ITreeNode<T>[]>;
+    hasChildren({ haveChildren }: ITreeNode<T>): boolean;
+    equals(value1: ITreeNode<T>, value2: ITreeNode<T>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SyncTreeLoaderService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SyncTreeLoaderService<any>>;
+}

package/{src/lib/components/inputs/param-tree/tokens/param-tree.tokens.ts → lib/components/inputs/param-tree/tokens/param-tree.tokens.d.ts}

@@ -1,4 +1,3 @@
 import { InjectionToken } from '@angular/core';
 import { SmaTreeLoader } from '../types/param-tree.types';
-
-export const TREE_LOADER = new InjectionToken<SmaTreeLoader<unknown>>('SMA_TREE_LOADER');
+export declare const TREE_LOADER: InjectionToken<SmaTreeLoader<unknown>>;

package/lib/components/inputs/param-tree/types/param-tree.types.d.ts

@@ -0,0 +1,32 @@
+import { TuiHandler } from '@taiga-ui/cdk';
+import { TuiTreeLoader } from '@taiga-ui/kit';
+export interface SmaTreeLoader<T> extends TuiTreeLoader<T> {
+    equals(value1: T, value2: T): boolean;
+}
+/** Конфиг для подгрузки дочерних узлов */
+export interface ILoadConfig<T> {
+    /** Узел для которого происходит загрузка */
+    node: ITreeNode<T>;
+    /** Дополнительная конфигурация загрузки */
+    config?: {
+        /** Является ли текущая загрузка начальной (для инициализации верхнего уровня узлов) */
+        initial?: boolean;
+        /**
+         * Режим загрузки дочерних узлов.
+         * Если true - дочерние узлы загружаются рекурсивно до последнего уровня
+         * */
+        opened?: boolean;
+    };
+}
+export interface ITreeNode<T = any> {
+    /** Название узла */
+    name: string;
+    parent?: ITreeNode<T>;
+    /** Есть дочерние узлы которые можно загрузить */
+    haveChildren?: boolean;
+    /** Дочерние загруженные узлы */
+    children?: ITreeNode<T>[];
+    /** Дополнительные свойства узла */
+    data?: T;
+}
+export type ChildrenHandlerType<NodeType> = TuiHandler<ITreeNode<NodeType>, readonly ITreeNode<NodeType>[]>;

package/lib/components/inputs/param-tree/utils/param-tree.utils.d.ts

@@ -0,0 +1,7 @@
+import { ITreeNode } from '../types/param-tree.types';
+interface IArgs<T> {
+    item: T;
+    children?: ITreeNode<T>[];
+}
+export declare function transformItemToNode<T extends Record<string, any>>({ item, children, }: IArgs<T>): ITreeNode<T>;
+export {};

package/lib/components/inputs/param-tree-multi-select/param-tree-multi-select.component.d.ts

@@ -0,0 +1,31 @@
+import { Injector } from '@angular/core';
+import { ITreeNode } from '../param-tree/types/param-tree.types';
+import { ParamSelectBase } from '../../../core/param/param-select-base';
+import * as i0 from "@angular/core";
+export type InputTreeSelectSavedValue<T> = ITreeNode<T> & {
+    [key: string]: any;
+};
+/** Компонент выбора единственного значения из иерархического списка */
+export declare class ParamTreeMultiSelectComponent<T> extends ParamSelectBase<ITreeNode<T>[], InputTreeSelectSavedValue<T>[]> {
+    /** Передача загрузочного узла для загрузки начального уровня иерархического списка */
+    loaderNode: import("@angular/core").InputSignal<ITreeNode<T>>;
+    /**
+     * Возможность раскрывать/скрывать узлы иерархического списка.
+     * Логическое значение - это значение узла по умолчанию (раскрыты/скрыты).
+     *
+     * @default Без указания параметра (или значении null) - все узлы раскрыты без возможности изменять состояние.
+     * */
+    defaultNodeOpenedState: import("@angular/core").InputSignal<boolean | undefined>;
+    stringify: import("@angular/core").InputSignal<(item: ITreeNode<T>) => string>;
+    shortPickedLength: import("@angular/core").InputSignal<boolean>;
+    readonly buildShowedValue: import("@angular/core").InputSignal<(values: ITreeNode[]) => string>;
+    placeholder: import("@angular/core").InputSignal<string>;
+    private readonly _treeService;
+    protected readonly checkedNodes: import("@angular/core").WritableSignal<ITreeNode<T>[]>;
+    constructor(injector: Injector);
+    protected afterViewInit(): void;
+    private _subscribeForUpdateCheckedNodes;
+    protected setSelectedNodes(node: ITreeNode<T>[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamTreeMultiSelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamTreeMultiSelectComponent<any>, "sproc-param-tree-multi-select", never, { "loaderNode": { "alias": "loaderNode"; "required": true; "isSignal": true; }; "defaultNodeOpenedState": { "alias": "defaultNodeOpenedState"; "required": false; "isSignal": true; }; "stringify": { "alias": "stringify"; "required": false; "isSignal": true; }; "shortPickedLength": { "alias": "shortPickedLength"; "required": false; "isSignal": true; }; "buildShowedValue": { "alias": "buildShowedValue"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/inputs/param-tree-select/param-tree-select.component.d.ts

@@ -0,0 +1,30 @@
+import { Injector } from '@angular/core';
+import { ITreeNode } from '../param-tree/types/param-tree.types';
+import { ParamSelectBase } from '../../../core/param/param-select-base';
+import * as i0 from "@angular/core";
+export type InputTreeSelectSavedValue<T> = ITreeNode<T> & {
+    [key: string]: any;
+};
+/** Компонент выбора единственного значения из иерархического списка */
+export declare class ParamTreeSelectComponent<T> extends ParamSelectBase<ITreeNode<T>, InputTreeSelectSavedValue<T>> {
+    /** Передача загрузочного узла для загрузки начального уровня иерархического списка */
+    loaderNode: import("@angular/core").InputSignal<ITreeNode<T>>;
+    /**
+     * Возможность раскрывать/скрывать узлы иерархического списка.
+     * Логическое значение - это значение узла по умолчанию (раскрыты/скрыты).
+     *
+     * @default Без указания параметра (или значении null) - все узлы раскрыты без возможности изменять состояние.
+     * */
+    defaultNodeOpenedState: import("@angular/core").InputSignal<boolean | undefined>;
+    stringify: import("@angular/core").InputSignal<(item: ITreeNode<T>) => string>;
+    buildShowedValue: import("@angular/core").InputSignal<(value: ITreeNode<T>) => string>;
+    placeholder: import("@angular/core").InputSignal<string>;
+    private readonly _treeService;
+    protected readonly checkedNodes: import("@angular/core").WritableSignal<ITreeNode<T>[]>;
+    constructor(injector: Injector);
+    protected afterViewInit(): void;
+    private _subscribeForUpdateCheckedNodes;
+    protected setSelectedNodes([node]: ITreeNode<T>[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamTreeSelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamTreeSelectComponent<any>, "sproc-param-tree-select", never, { "loaderNode": { "alias": "loaderNode"; "required": true; "isSignal": true; }; "defaultNodeOpenedState": { "alias": "defaultNodeOpenedState"; "required": false; "isSignal": true; }; "stringify": { "alias": "stringify"; "required": false; "isSignal": true; }; "buildShowedValue": { "alias": "buildShowedValue"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/inputs/sub-components/param-delete-content-icon/param-delete-content-btn.component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class ParamDeleteContentBtnComponent {
+    readonly iconClicked: import("@angular/core").OutputEmitterRef<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamDeleteContentBtnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamDeleteContentBtnComponent, "sproc-param-delete-content-button", never, {}, { "iconClicked": "iconClicked"; }, never, never, true, never>;
+}

package/lib/components/inputs/sub-components/param-invalid-icon/param-invalid-icon.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class ParamInvalidIconComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParamInvalidIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParamInvalidIconComponent, "sproc-param-invalid-icon", never, {}, {}, never, never, true, never>;
+}

package/lib/components/menu-constructor/sproc-menu-constructor.component.d.ts

@@ -0,0 +1,113 @@
+import { OnInit } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { FlatNode, IMenuConstructorError } from './store/sproc-menu-constructor.consts';
+import * as i0 from "@angular/core";
+export declare class SprocMenuConstructorComponent implements OnInit {
+    private _store;
+    private _ref;
+    protected ROOT_TITLE: string;
+    protected loading$: import("rxjs").Observable<boolean>;
+    protected originalTree: Map<string, FlatNode>;
+    protected MIGRATION_HINT: string;
+    private deletedIds;
+    errorMsgOutput: import("@angular/core").OutputEmitterRef<IMenuConstructorError>;
+    protected flatTree: import("@angular/core").WritableSignal<FlatNode[]>;
+    protected draggedBranch: import("@angular/core").WritableSignal<FlatNode[]>;
+    protected visibleFlatTree: import("@angular/core").Signal<FlatNode[]>;
+    private _pendingRecalc;
+    ngOnInit(): void;
+    /**
+     * Переключает состояние свернутости узла (collapse/expand)
+     * После изменения создает новый массив для триггера обновления сигнала
+     */
+    protected toggleCollapse(node: FlatNode): void;
+    /**
+     * Начало перетаскивания: сохраняет всю ветку узла, которую тянут
+     */
+    protected dragStarted(node: FlatNode): void;
+    /**
+     * Завершение перетаскивания: очищает информацию о текущей ветке
+     */
+    protected dragEnded(): void;
+    /**
+     * Основная логика drag&drop при отпускании элемента
+     * Определяет новую позицию узла, пересчитывает глубины и связи
+     */
+    protected drop(event: CdkDragDrop<FlatNode[]>): void;
+    /**
+     * Увеличивает глубину (depth) конкретного узла, если возможно
+     */
+    protected indent(node: FlatNode): void;
+    /**
+     * Уменьшает глубину (depth) узла + по возможности превращает его в родителя
+     */
+    protected outdent(node: FlatNode): void;
+    /**
+     * Увеличивает глубину всей ветки узла (вместе с потомками)
+     */
+    protected indentBranch(node: FlatNode): void;
+    /**
+     * Уменьшает глубину всей ветки узла
+     */
+    protected outdentBranch(node: FlatNode): void;
+    /**
+     * Проверяет, есть ли у узла дочерние элементы
+     */
+    protected hasChildren(node: FlatNode): boolean;
+    protected save(): void;
+    protected handleFold(state: boolean): void;
+    /**
+     * Удаляет один элемент из дерева.
+     * Потомки становятся дочерними элементами родителя удалённого узла.
+     */
+    protected deleteItem(node: FlatNode): void;
+    /**
+     * Добавляет новый элемент в дерево.
+     * По умолчанию он создаётся как дочерний элемент root.
+     */
+    protected addNewItem(): void;
+    /**
+     * Сбрасывает текущее состояние в исходное
+     */
+    protected reset(): void;
+    /**
+     * Проверяет, находится ли элемент в текущей перетаскиваемой ветке
+     */
+    protected isDragged(node: FlatNode): boolean;
+    /**
+     * Собирает всю ветку элементов начиная с указанного узла (включая потомков)
+     */
+    private _collectBranch;
+    /**
+     * Сдвигает глубину всех элементов ветки на указанную разницу
+     * Не допускает отрицательных глубин
+     */
+    private _applyDepthShift;
+    /**
+     * Преобразует иерархический JSON в плоский массив FlatNode[]
+     * Сохраняет порядок элементов и их вложенность
+     */
+    private _convertToFlatNode;
+    /**
+     * Возвращает список видимых элементов на основе флагов collapsed
+     * Использует стек для отслеживания свернутости на каждом уровне
+     */
+    private _getVisibleFrom;
+    /**
+     * Пересчитывает order_num и id_parent у всех элементов массива
+     * После перемещений поддерживает корректную структуру дерева
+     * order_num назначается относительно родителя (1..N)
+     */
+    private _recalculateTree;
+    /**
+     * Асинхронно планирует пересчет дерева через requestAnimationFrame
+     * Это предотвращает множественные лишние пересчеты при частых изменениях
+     */
+    private _scheduleRecalc;
+    /**
+     * Проверяет равенство двух массивов FlatNode по ключевым свойствам
+     */
+    private _arraysEqual;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SprocMenuConstructorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SprocMenuConstructorComponent, "sproc-menu-constructor", never, {}, { "errorMsgOutput": "errorMsgOutput"; }, never, never, true, never>;
+}

package/lib/components/menu-constructor/store/sproc-abstract-menu-constructor.store.d.ts

@@ -0,0 +1,24 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { IClsMenuItemInput } from './sproc-menu-constructor.consts';
+import { IClsMenuItem } from '../../page-menu';
+import { Apollo } from 'apollo-angular';
+import { DestroyRef } from '@angular/core';
+import { ScalarUUID } from 'hasura';
+export declare abstract class SprocAbstractMenuConstructorStore {
+    protected abstract _menuItems$: BehaviorSubject<IClsMenuItem[]>;
+    protected abstract _loading$: BehaviorSubject<boolean>;
+    protected abstract _apollo: Apollo;
+    protected abstract _dr: DestroyRef;
+    abstract menuItems$: Observable<IClsMenuItem[]>;
+    abstract loading$: Observable<boolean>;
+    abstract originalMenu: IClsMenuItem[];
+    abstract getMenu(): IClsMenuItem[];
+    abstract updateMenu(objectsToUpdate: {
+        _set: IClsMenuItemInput;
+        where: {
+            [key: string]: any;
+        };
+    }[], objectsToInsert?: IClsMenuItemInput[], idsToDelete?: ScalarUUID[]): void;
+    protected abstract setLoading(state: boolean): void;
+    protected abstract _fetchMenu(): void;
+}