ngx-register-base 1.3.1 → 1.3.2

package/esm2022/lib/core/param/param-base.mjs

@@ -0,0 +1,215 @@
+import { ChangeDetectorRef, computed, DestroyRef, Directive, forwardRef, inject, input, Input, Optional, Self, } from '@angular/core';
+import { NG_VALUE_ACCESSOR, NgControl, Validators } from '@angular/forms';
+import { filter, skip, tap } from 'rxjs';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { distinctUntilChangedJSONs } from '../../utils';
+import * as i0 from "@angular/core";
+export class ParamBase {
+    /** Метод для конвертации значения control при сохранении (используется при сохранении фильтров в БД) */
+    set formatSavedValue(formatter) {
+        if (formatter) {
+            this.formatterSavedValue = formatter;
+        }
+    }
+    /** Метод для конвертации сохраненного значения в control (используется при установке сохраненных фильтров из БД) */
+    set parseSavedValue(parser) {
+        if (parser) {
+            this.parserSavedValue = parser;
+        }
+    }
+    /** Метод для конвертации значения control в GQL-значение (используется при вычислении gql_value control) */
+    set formatGqlValue(formatter) {
+        if (formatter) {
+            this.formatterGqlValue = formatter;
+        }
+    }
+    set required(required) {
+        this._required = required;
+        this._setControlRequired(required);
+    }
+    get required() {
+        return this.control?.hasValidator(Validators.required) ?? false;
+    }
+    set disabled(disabled) {
+        this._disabled = disabled;
+        this._setControlDisabled(disabled);
+    }
+    get disabled() {
+        return this.control?.disabled ?? false;
+    }
+    constructor(_injector) {
+        this._injector = _injector;
+        /** Название */
+        this.label = '';
+        /** Текст при пустом значении control (null) */
+        this.placeholder = input('');
+        /** Режим просмотра, по умолчанию выключен */
+        this.readmode = false;
+        /** Кнопка быстрой очистки поля, по умолчанию включена */
+        this.forceClear = true;
+        /** Текст при наведении на значение control */
+        this.hint = null;
+        /** Готовые стили для использования поля в панели фильтров/параметров или на карточке, по умолчанию стили для карточки */
+        this.paramStyle = 'card';
+        /** Метод для отображения значения в режиме просмотра */
+        this.buildShowedValue = input((_) => '');
+        this._ngControl = inject(NgControl);
+        this.cdr = inject(ChangeDetectorRef);
+        this.dr = inject(DestroyRef);
+        this.formatterSavedValue = (value) => value;
+        this.parserSavedValue = (value) => value;
+        this.formatterGqlValue = (_) => undefined;
+        this._required = false;
+        this._disabled = false;
+        this._isOuterUpdatingSavedValue = true;
+        this.showedValue = '';
+        this.applied = computed(() => this.control.applied?.() ?? false);
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        if (this._ngControl) {
+            this._ngControl.valueAccessor = this;
+        }
+    }
+    get value() {
+        return this.control?.getRawValue();
+    }
+    writeValue(value) {
+        this._updateShowedValue(value);
+    }
+    clear() {
+        this.control.reset();
+        this.control.markAsDirty();
+    }
+    registerOnChange(onChange) {
+        this.onChange = onChange;
+    }
+    registerOnTouched(onTouched) {
+        this.onTouched = onTouched;
+    }
+    ngOnInit() {
+        this.onInit();
+    }
+    onInit() { }
+    ngAfterViewInit() {
+        this.afterViewInit();
+    }
+    afterViewInit() { }
+    get isInvalidAndNotPristine() {
+        return this.control.invalid && !this.control.pristine;
+    }
+    isNotEmpty() {
+        const v = this.value;
+        return !(v === null ||
+            v === undefined ||
+            (typeof v === 'string' && v.trim() === '') ||
+            (Array.isArray(v) && v.length === 0) ||
+            (typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length === 0));
+    }
+    ngAfterContentInit() {
+        this.control =
+            this._ngControl && this._ngControl.control;
+        if (this.control) {
+            if (this._required) {
+                this._setControlRequired(this._required);
+            }
+            if (this._disabled) {
+                this._setControlDisabled(this._disabled);
+            }
+            this._subscribeOnValue();
+            this._subscribeOnSavedValue();
+        }
+        this.afterContentInit();
+    }
+    _subscribeOnValue() {
+        this.control.valueChanges
+            .pipe(distinctUntilChangedJSONs(), tap((value) => this._updateSavedValue(value)), takeUntilDestroyed(this.dr))
+            .subscribe((value) => {
+            this.control.gql_value = this.formatterGqlValue(value, this._injector);
+            this._updateShowedValue(value);
+            if (this.isNotEmpty()) {
+                this.control.applied?.set(false);
+            }
+        });
+    }
+    _updateShowedValue(value) {
+        this.showedValue = this.buildShowedValue()(value);
+        this.cdr.markForCheck();
+    }
+    _updateSavedValue(value) {
+        this._isOuterUpdatingSavedValue = false;
+        const savedValue = this.formatterSavedValue(value, this._injector);
+        this.control.saved_value$?.next(savedValue);
+        this._isOuterUpdatingSavedValue = true;
+    }
+    _subscribeOnSavedValue() {
+        this.control.saved_value$
+            ?.pipe(skip(1), // при подписывании на saved_value$ первым приходит null - пропускаем
+        filter(() => this._isOuterUpdatingSavedValue), takeUntilDestroyed(this.dr))
+            .subscribe((savedValue) => {
+            const value = savedValue === null ? null : this.parserSavedValue(savedValue, this._injector);
+            this.control.setValue(value);
+        });
+    }
+    afterContentInit() { }
+    _setControlRequired(required) {
+        if (required) {
+            this.control?.addValidators(Validators.required);
+        }
+        else {
+            this.control?.removeValidators(Validators.required);
+        }
+    }
+    _setControlDisabled(disabled) {
+        if (disabled) {
+            this.control?.disable();
+        }
+        else {
+            this.control?.enable();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamBase, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.14", type: ParamBase, inputs: { label: { classPropertyName: "label", publicName: "label", isSignal: false, isRequired: false, transformFunction: null }, placeholder: { classPropertyName: "placeholder", publicName: "placeholder", isSignal: true, isRequired: false, transformFunction: null }, readmode: { classPropertyName: "readmode", publicName: "readmode", isSignal: false, isRequired: false, transformFunction: null }, forceClear: { classPropertyName: "forceClear", publicName: "forceClear", isSignal: false, isRequired: false, transformFunction: null }, hint: { classPropertyName: "hint", publicName: "hint", isSignal: false, isRequired: false, transformFunction: null }, paramStyle: { classPropertyName: "paramStyle", publicName: "paramStyle", isSignal: false, isRequired: false, transformFunction: null }, formatSavedValue: { classPropertyName: "formatSavedValue", publicName: "formatSavedValue", isSignal: false, isRequired: false, transformFunction: null }, parseSavedValue: { classPropertyName: "parseSavedValue", publicName: "parseSavedValue", isSignal: false, isRequired: false, transformFunction: null }, formatGqlValue: { classPropertyName: "formatGqlValue", publicName: "formatGqlValue", isSignal: false, isRequired: false, transformFunction: null }, buildShowedValue: { classPropertyName: "buildShowedValue", publicName: "buildShowedValue", isSignal: true, isRequired: false, transformFunction: null }, required: { classPropertyName: "required", publicName: "required", isSignal: false, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: false, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => ParamBase),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamBase, decorators: [{
+            type: Directive,
+            args: [{
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => ParamBase),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }], propDecorators: { label: [{
+                type: Input
+            }], readmode: [{
+                type: Input
+            }], forceClear: [{
+                type: Input
+            }], hint: [{
+                type: Input
+            }], paramStyle: [{
+                type: Input
+            }], formatSavedValue: [{
+                type: Input
+            }], parseSavedValue: [{
+                type: Input
+            }], formatGqlValue: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], _ngControl: [{
+                type: Optional
+            }, {
+                type: Self
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"param-base.js","sourceRoot":"","sources":["../../../../../../projects/ngx-register-base/src/lib/core/param/param-base.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  AfterViewInit,\n  ChangeDetectorRef,\n  computed,\n  DestroyRef,\n  Directive,\n  forwardRef,\n  inject,\n  Injector,\n  input,\n  Input,\n  OnInit,\n  Optional,\n  Self,\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR, NgControl, Validators } from '@angular/forms';\nimport { filter, skip, tap } from 'rxjs';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { IInputControl, InputControlGqlValue, InputControlSaveValue } from '../../types';\nimport {\n  FormatterGqlValueType,\n  FormatterSavedValueType,\n  ParserSavedValueType,\n} from '../../types/params.types';\nimport { distinctUntilChangedJSONs } from '../../utils';\n\n@Directive({\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => ParamBase),\n      multi: true,\n    },\n  ],\n})\nexport abstract class ParamBase<\n    ValueType extends any | null,\n    SavedValueType extends InputControlSaveValue,\n  >\n  implements ControlValueAccessor, OnInit, AfterViewInit, AfterContentInit\n{\n  /** Название */\n  @Input() label = '';\n  /** Текст при пустом значении control (null) */\n  placeholder = input<string>('');\n  /** Режим просмотра, по умолчанию выключен */\n  @Input() readmode = false;\n  /** Кнопка быстрой очистки поля, по умолчанию включена */\n  @Input() forceClear = true;\n  /** Текст при наведении на значение control */\n  @Input() hint: string | null = null;\n  /** Готовые стили для использования поля в панели фильтров/параметров или на карточке, по умолчанию стили для карточки */\n  @Input() paramStyle: 'filter' | 'card' = 'card';\n  /** Метод для конвертации значения control при сохранении (используется при сохранении фильтров в БД) */\n  @Input() set formatSavedValue(\n    formatter: FormatterSavedValueType<ValueType, SavedValueType> | undefined\n  ) {\n    if (formatter) {\n      this.formatterSavedValue = formatter;\n    }\n  }\n  /** Метод для конвертации сохраненного значения в control (используется при установке сохраненных фильтров из БД) */\n  @Input() set parseSavedValue(\n    parser: ParserSavedValueType<SavedValueType, ValueType> | undefined\n  ) {\n    if (parser) {\n      this.parserSavedValue = parser;\n    }\n  }\n  /** Метод для конвертации значения control в GQL-значение (используется при вычислении gql_value control) */\n  @Input() set formatGqlValue(formatter: FormatterGqlValueType<ValueType> | undefined) {\n    if (formatter) {\n      this.formatterGqlValue = formatter;\n    }\n  }\n  /** Метод для отображения значения в режиме просмотра */\n  buildShowedValue = input((_: ValueType): string => '');\n\n  @Input() set required(required: boolean) {\n    this._required = required;\n    this._setControlRequired(required);\n  }\n\n  public get required(): boolean {\n    return this.control?.hasValidator(Validators.required) ?? false;\n  }\n\n  @Input() set disabled(disabled: boolean) {\n    this._disabled = disabled;\n    this._setControlDisabled(disabled);\n  }\n\n  public get disabled(): boolean {\n    return this.control?.disabled ?? false;\n  }\n\n  @Optional()\n  @Self()\n  private readonly _ngControl = inject(NgControl);\n\n  protected readonly cdr = inject(ChangeDetectorRef);\n  protected readonly dr = inject(DestroyRef);\n\n  protected control!: IInputControl<ValueType, SavedValueType>;\n  protected formatterSavedValue: (value: ValueType, injector?: Injector) => SavedValueType = (\n    value\n  ) => value as unknown as SavedValueType;\n  protected parserSavedValue: (value: SavedValueType, injector?: Injector) => ValueType = (value) =>\n    value as unknown as ValueType;\n  protected formatterGqlValue: (value: ValueType, injector?: Injector) => InputControlGqlValue = (\n    _\n  ) => undefined as InputControlGqlValue;\n\n  private _required = false;\n  private _disabled = false;\n  private _isOuterUpdatingSavedValue = true;\n\n  protected showedValue = '';\n\n  protected readonly applied = computed(() => this.control.applied?.() ?? false);\n\n  constructor(private _injector: Injector) {\n    if (this._ngControl) {\n      this._ngControl.valueAccessor = this;\n    }\n  }\n\n  public get value(): ValueType | undefined {\n    return this.control?.getRawValue();\n  }\n\n  public writeValue(value: ValueType): void {\n    this._updateShowedValue(value);\n  }\n\n  public clear(): void {\n    this.control.reset();\n    this.control.markAsDirty();\n  }\n\n  public registerOnChange(onChange: (value: ValueType) => void): void {\n    this.onChange = onChange;\n  }\n\n  protected onChange: (value: ValueType) => void = () => {};\n\n  public registerOnTouched(onTouched: () => void): void {\n    this.onTouched = onTouched;\n  }\n\n  protected onTouched = (): void => {};\n\n  public ngOnInit(): void {\n    this.onInit();\n  }\n\n  protected onInit(): void {}\n\n  public ngAfterViewInit(): void {\n    this.afterViewInit();\n  }\n\n  protected afterViewInit(): void {}\n\n  protected get isInvalidAndNotPristine(): boolean {\n    return this.control.invalid && !this.control.pristine;\n  }\n\n  protected isNotEmpty(): boolean {\n    const v = this.value;\n\n    return !(\n      v === null ||\n      v === undefined ||\n      (typeof v === 'string' && v.trim() === '') ||\n      (Array.isArray(v) && v.length === 0) ||\n      (typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length === 0)\n    );\n  }\n\n  public ngAfterContentInit(): void {\n    this.control =\n      this._ngControl && (this._ngControl.control as IInputControl<ValueType, SavedValueType>);\n\n    if (this.control) {\n      if (this._required) {\n        this._setControlRequired(this._required);\n      }\n\n      if (this._disabled) {\n        this._setControlDisabled(this._disabled);\n      }\n\n      this._subscribeOnValue();\n      this._subscribeOnSavedValue();\n    }\n\n    this.afterContentInit();\n  }\n\n  private _subscribeOnValue(): void {\n    this.control.valueChanges\n      .pipe(\n        distinctUntilChangedJSONs(),\n        tap((value) => this._updateSavedValue(value)),\n        takeUntilDestroyed(this.dr)\n      )\n      .subscribe((value) => {\n        this.control.gql_value = this.formatterGqlValue(value, this._injector);\n        this._updateShowedValue(value);\n\n        if (this.isNotEmpty()) {\n          this.control.applied?.set(false);\n        }\n      });\n  }\n\n  private _updateShowedValue(value: ValueType): void {\n    this.showedValue = this.buildShowedValue()(value);\n    this.cdr.markForCheck();\n  }\n\n  private _updateSavedValue(value: ValueType): void {\n    this._isOuterUpdatingSavedValue = false;\n    const savedValue = this.formatterSavedValue(value, this._injector);\n    this.control.saved_value$?.next(savedValue);\n    this._isOuterUpdatingSavedValue = true;\n  }\n\n  private _subscribeOnSavedValue(): void {\n    this.control.saved_value$\n      ?.pipe(\n        skip(1), // при подписывании на saved_value$ первым приходит null - пропускаем\n        filter(() => this._isOuterUpdatingSavedValue),\n        takeUntilDestroyed(this.dr)\n      )\n      .subscribe((savedValue) => {\n        const value =\n          savedValue === null ? null : this.parserSavedValue(savedValue, this._injector);\n        this.control.setValue(value as ValueType);\n      });\n  }\n\n  protected afterContentInit(): void {}\n\n  private _setControlRequired(required: boolean): void {\n    if (required) {\n      this.control?.addValidators(Validators.required);\n    } else {\n      this.control?.removeValidators(Validators.required);\n    }\n  }\n\n  private _setControlDisabled(disabled: boolean): void {\n    if (disabled) {\n      this.control?.disable();\n    } else {\n      this.control?.enable();\n    }\n  }\n}\n"]}

package/esm2022/lib/core/param/param-date-base.mjs

@@ -0,0 +1,26 @@
+import { Directive } from '@angular/core';
+import { DateTimeService } from '../../services/date-time.service';
+import { ParamBase } from './param-base';
+import { EDatePattern, ETimezone } from '../../directives/date/date-time.types';
+import * as i0 from "@angular/core";
+export class ParamDateBase extends ParamBase {
+    constructor(_dateInjector) {
+        super(_dateInjector);
+        this._dateInjector = _dateInjector;
+        this.ETimezone = ETimezone;
+        this.EDatePattern = EDatePattern;
+        this._dts = this._dateInjector.get(DateTimeService);
+        this.timezoneChange = this._dts.isTimeZoneChanged$;
+    }
+    rebuildDateInNewTimezone(date, prevDiff, currDiff) {
+        const iso = this._dts.convertDateToISOWithTZ(date, prevDiff);
+        const utc = new Date(iso).toISOString();
+        return this._dts.isoToLocalDate(utc, currDiff);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamDateBase, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: ParamDateBase, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamDateBase, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/param/param-select-base.mjs

@@ -0,0 +1,114 @@
+import { Directive, Input, output } from '@angular/core';
+import { ParamBase } from './param-base';
+import { BehaviorSubject } from 'rxjs';
+import { FastQueryStore } from '../../store/fast-query-store.service';
+import * as i0 from "@angular/core";
+export class ParamSelectBase extends ParamBase {
+    /** мета для автоматической подргузки значений из таблицы */
+    set meta(meta) {
+        if (JSON.stringify(meta) !== JSON.stringify(this.meta)) {
+            this._meta$.next(meta);
+        }
+    }
+    get meta() {
+        return this._meta$.getValue();
+    }
+    constructor(_selectInjector) {
+        super(_selectInjector);
+        this._selectInjector = _selectInjector;
+        this.items = [];
+        this.searchable = false;
+        this.maxDropdownHeight = 342;
+        this.nullContent = 'Не выбрано';
+        /** Массив полей по которым будет производиться фильтрация _or */
+        this.searchSubfields = [];
+        /** Флаг строгого поиска: строгий - _eq, не строгий - _ilike */
+        this.strictSearch = false;
+        this.limit = 50;
+        /** форматтер для задания кастомного отображения значения в поле */
+        this.formatShowedValue = (value, field) => value[field];
+        this.itemsChange = output();
+        this._meta$ = new BehaviorSubject(null);
+        this.meta$ = this._meta$.asObservable();
+        this.store = this._selectInjector.get(FastQueryStore);
+        this.loading = false;
+    }
+    buildWhere(searchValue) {
+        const paramWhere = this.meta?.where;
+        const { valueField } = this.metaFields;
+        // Создаем массив условий _ilike для дополнительных полей
+        const ilikeConditions = [];
+        if (searchValue) {
+            if (this.searchSubfields) {
+                ilikeConditions.push(...this.searchSubfields.map((field) => this.buildNestedCondition(field, searchValue, false)));
+            }
+            if (valueField) {
+                ilikeConditions.push(this.buildNestedCondition(valueField, searchValue, this.strictSearch));
+            }
+        }
+        // Если параметр where не задан, но есть значение для поиска и поле valueField, возвращаем только условия _ilike
+        if (!paramWhere && ilikeConditions.length > 0) {
+            return { _or: ilikeConditions };
+        }
+        // Если параметр where задан, добавляем условия _ilike к существующим условиям
+        if (paramWhere) {
+            return {
+                ...paramWhere,
+                _or: ilikeConditions.length === 0 ? undefined : ilikeConditions,
+            };
+        }
+        // Если ничего не задано, возвращаем undefined
+        return;
+    }
+    buildNestedCondition(field, value, strict) {
+        const parts = field.split('.');
+        const current = {};
+        let temp = current;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            temp[part] = {};
+            temp = temp[part];
+        }
+        const lastPart = parts[parts.length - 1];
+        temp[lastPart] = strict ? { _eq: value } : { _ilike: `%${value}%` };
+        return current;
+    }
+    get metaFields() {
+        const idField = this.meta?.table.idField ?? null;
+        const valueField = this.meta?.table.valueField.split(' ')[0] ?? null;
+        return {
+            idField,
+            valueField,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamSelectBase, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: ParamSelectBase, inputs: { items: "items", searchable: "searchable", maxDropdownHeight: "maxDropdownHeight", valueTemplate: "valueTemplate", listItemTemplate: "listItemTemplate", nullContent: "nullContent", searchSubfields: "searchSubfields", strictSearch: "strictSearch", selectClasses: "selectClasses", limit: "limit", formatShowedValue: "formatShowedValue", meta: "meta" }, outputs: { itemsChange: "itemsChange" }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamSelectBase, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.Injector }], propDecorators: { items: [{
+                type: Input
+            }], searchable: [{
+                type: Input
+            }], maxDropdownHeight: [{
+                type: Input
+            }], valueTemplate: [{
+                type: Input
+            }], listItemTemplate: [{
+                type: Input
+            }], nullContent: [{
+                type: Input
+            }], searchSubfields: [{
+                type: Input
+            }], strictSearch: [{
+                type: Input
+            }], selectClasses: [{
+                type: Input
+            }], limit: [{
+                type: Input
+            }], formatShowedValue: [{
+                type: Input
+            }], meta: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"param-select-base.js","sourceRoot":"","sources":["../../../../../../projects/ngx-register-base/src/lib/core/param/param-select-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Injector, Input, output } from '@angular/core';\nimport { ParamBase } from './param-base';\nimport { BehaviorSubject } from 'rxjs';\nimport { PolymorphContent } from '@prizm-ui/components';\nimport { InputControlSaveValue } from '../../types';\nimport { InferArrayType } from '../../types/sub-types';\nimport { MetaQuery } from '../../types/params.types';\nimport { FastQueryStore } from '../../store/fast-query-store.service';\n\n@Directive()\nexport abstract class ParamSelectBase<\n  ValueType,\n  SavedValueType extends InputControlSaveValue,\n> extends ParamBase<ValueType, SavedValueType> {\n  @Input() items: NonNullable<InferArrayType<ValueType>>[] = [];\n  @Input() searchable: boolean = false;\n  @Input() maxDropdownHeight = 342;\n  @Input() valueTemplate?: PolymorphContent;\n  @Input() listItemTemplate?: PolymorphContent;\n  @Input() nullContent: PolymorphContent | string | null = 'Не выбрано';\n  /** Массив полей по которым будет производиться фильтрация _or */\n  @Input() searchSubfields: string[] = [];\n  /** Флаг строгого поиска: строгий - _eq, не строгий - _ilike */\n  @Input() strictSearch = false;\n  @Input() selectClasses?: string;\n  @Input() limit = 50;\n  /** форматтер для задания кастомного отображения значения в поле */\n  @Input() formatShowedValue: (value: any, field: string) => string = (value, field) =>\n    value[field];\n  /** мета для автоматической подргузки значений из таблицы */\n  @Input() set meta(meta: MetaQuery | null) {\n    if (JSON.stringify(meta) !== JSON.stringify(this.meta)) {\n      this._meta$.next(meta);\n    }\n  }\n  public get meta(): MetaQuery | null {\n    return this._meta$.getValue();\n  }\n\n  public itemsChange = output<NonNullable<InferArrayType<ValueType>>[]>();\n\n  private readonly _meta$ = new BehaviorSubject<MetaQuery | null>(null);\n\n  protected readonly meta$ = this._meta$.asObservable();\n\n  protected readonly store = this._selectInjector.get(FastQueryStore);\n\n  public loading = false;\n\n  constructor(private _selectInjector: Injector) {\n    super(_selectInjector);\n  }\n\n  protected buildWhere(searchValue?: string): object | undefined {\n    const paramWhere = this.meta?.where;\n    const { valueField } = this.metaFields;\n\n    // Создаем массив условий _ilike для дополнительных полей\n    const ilikeConditions = [];\n\n    if (searchValue) {\n      if (this.searchSubfields) {\n        ilikeConditions.push(\n          ...this.searchSubfields.map((field) =>\n            this.buildNestedCondition(field, searchValue, false)\n          )\n        );\n      }\n\n      if (valueField) {\n        ilikeConditions.push(this.buildNestedCondition(valueField, searchValue, this.strictSearch));\n      }\n    }\n\n    // Если параметр where не задан, но есть значение для поиска и поле valueField, возвращаем только условия _ilike\n    if (!paramWhere && ilikeConditions.length > 0) {\n      return { _or: ilikeConditions };\n    }\n\n    // Если параметр where задан, добавляем условия _ilike к существующим условиям\n    if (paramWhere) {\n      return {\n        ...(paramWhere as object),\n        _or: ilikeConditions.length === 0 ? undefined : ilikeConditions,\n      };\n    }\n\n    // Если ничего не задано, возвращаем undefined\n    return;\n  }\n\n  protected buildNestedCondition(field: string, value: string, strict: boolean): object {\n    const parts = field.split('.');\n    const current = {};\n    let temp: any = current;\n\n    for (let i = 0; i < parts.length - 1; i++) {\n      const part = parts[i];\n      temp[part] = {};\n      temp = temp[part];\n    }\n\n    const lastPart = parts[parts.length - 1];\n    temp[lastPart] = strict ? { _eq: value } : { _ilike: `%${value}%` };\n\n    return current;\n  }\n\n  protected get metaFields(): { idField: string | null; valueField: string | null } {\n    const idField = this.meta?.table.idField ?? null;\n    const valueField = this.meta?.table.valueField.split(' ')[0] ?? null;\n\n    return {\n      idField,\n      valueField,\n    };\n  }\n}\n"]}

package/esm2022/lib/core/param/param-text-base.mjs

@@ -0,0 +1,25 @@
+import { Directive, inject, input } from '@angular/core';
+import { ParamBase } from './param-base';
+import { MAX_LENGTH_TEXT_PARAMS } from './param.tokens';
+import * as i0 from "@angular/core";
+const DEFAULT_MAX_LENGTH = 1000;
+export class ParamTextBase extends ParamBase {
+    constructor() {
+        super(...arguments);
+        this._initMaxLength = inject(MAX_LENGTH_TEXT_PARAMS, { optional: true }) ?? DEFAULT_MAX_LENGTH;
+        this.placeholder = input('Введите значение');
+        this.buildShowedValue = input((value) => value?.toString() ?? '-');
+        /**
+         * Максимальное кол-во символов
+         *
+         * @default 1000
+         * */
+        this.maxLength = input(this._initMaxLength);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamTextBase, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.14", type: ParamTextBase, inputs: { placeholder: { classPropertyName: "placeholder", publicName: "placeholder", isSignal: true, isRequired: false, transformFunction: null }, buildShowedValue: { classPropertyName: "buildShowedValue", publicName: "buildShowedValue", isSignal: true, isRequired: false, transformFunction: null }, maxLength: { classPropertyName: "maxLength", publicName: "maxLength", isSignal: true, isRequired: false, transformFunction: null } }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ParamTextBase, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/param/param.tokens.mjs

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+/** Максимальное кол-во символов в текстовых полях */
+export const MAX_LENGTH_TEXT_PARAMS = new InjectionToken('MAX_LENGTH_TEXT_PARAMS');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyYW0udG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJlZ2lzdGVyLWJhc2Uvc3JjL2xpYi9jb3JlL3BhcmFtL3BhcmFtLnRva2Vucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLHFEQUFxRDtBQUNyRCxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxJQUFJLGNBQWMsQ0FBUyx3QkFBd0IsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqINCc0LDQutGB0LjQvNCw0LvRjNC90L7QtSDQutC+0Lst0LLQviDRgdC40LzQstC+0LvQvtCyINCyINGC0LXQutGB0YLQvtCy0YvRhSDQv9C+0LvRj9GFICovXG5leHBvcnQgY29uc3QgTUFYX0xFTkdUSF9URVhUX1BBUkFNUyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxudW1iZXI+KCdNQVhfTEVOR1RIX1RFWFRfUEFSQU1TJyk7XG4iXX0=

package/esm2022/lib/core/register-base/index.mjs

@@ -0,0 +1,3 @@
+export { RegisterBase } from './register-base';
+export { RegisterBaseStore } from './register-base.store';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtcmVnaXN0ZXItYmFzZS9zcmMvbGliL2NvcmUvcmVnaXN0ZXItYmFzZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBSZWdpc3RlckJhc2UgfSBmcm9tICcuL3JlZ2lzdGVyLWJhc2UnO1xuZXhwb3J0IHsgUmVnaXN0ZXJCYXNlU3RvcmUgfSBmcm9tICcuL3JlZ2lzdGVyLWJhc2Uuc3RvcmUnO1xuIl19