special-forms 0.0.1

package/lib/components/special-input/special-input.component.d.ts

@@ -0,0 +1,15 @@
+import { OnInit } from '@angular/core';
+import { SpecialFormControl } from '../../core/forms/special-forms';
+import { IInputSettings } from './special-input.interface';
+import * as i0 from "@angular/core";
+export declare class SpecialInputComponent implements OnInit {
+    control: SpecialFormControl<IInputSettings>;
+    constructor();
+    ngOnInit(): void;
+    onEnterClick(): void;
+    onBlurAction(): void;
+    get settings(): IInputSettings;
+    iconClick(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialInputComponent, "sp-input", never, { "control": "control"; }, {}, never, never, false>;
+}

package/lib/components/special-input/special-input.interface.d.ts

@@ -0,0 +1,15 @@
+import { InputmaskOptions } from '@ngneat/input-mask';
+import { EControlTypes } from '../../core/aux-data/control-types.enum';
+import { IFieldData } from '../../core/interfaces/field-basics.interfaces';
+export declare type IInputSettings = {
+    type?: string;
+    mask?: InputmaskOptions<any>;
+    icon?: string;
+    iconAction?: (data: any) => void;
+    onEnter?: (data: any) => void;
+    onBlur?: (data: any) => void;
+};
+export interface IInputField extends IFieldData {
+    settings: IInputSettings;
+    type: EControlTypes.input;
+}

package/lib/components/special-input/special-input.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./special-input.component";
+import * as i2 from "@ngneat/input-mask";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/input";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/forms";
+import * as i7 from "@angular/material/button";
+import * as i8 from "../../pipes/error-message-pipe/error.pipe.module";
+export declare class SpecialInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SpecialInputModule, [typeof i1.SpecialInputComponent], [typeof i2.InputMaskModule, typeof i3.CommonModule, typeof i4.MatInputModule, typeof i5.MatIconModule, typeof i6.ReactiveFormsModule, typeof i7.MatButtonModule, typeof i8.ErrorMessagePipeModule], [typeof i1.SpecialInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SpecialInputModule>;
+}

package/lib/components/special-label/special-label.component.d.ts

@@ -0,0 +1,13 @@
+import { OnInit } from '@angular/core';
+import { SpecialFormControl } from '../../core/forms/special-forms';
+import { ILabelSettings } from './special-label.interface';
+import * as i0 from "@angular/core";
+export declare class SpecialLabelComponent implements OnInit {
+    control: SpecialFormControl<ILabelSettings>;
+    constructor();
+    ngOnInit(): void;
+    get settings(): ILabelSettings;
+    onLink(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialLabelComponent, "sp-label", never, { "control": "control"; }, {}, never, never, false>;
+}

package/lib/components/special-label/special-label.interface.d.ts

@@ -0,0 +1,12 @@
+import { EControlTypes } from '../../core/aux-data/control-types.enum';
+import { IFieldData } from '../../core/interfaces/field-basics.interfaces';
+export declare type ILabelSettings = {
+    pipe?: (value: any) => string;
+    stylesPipe?: (value: any) => string;
+    isLink: boolean;
+    onClickLink?: (value: any) => void;
+};
+export interface ILabelField extends IFieldData {
+    settings: ILabelSettings;
+    type: EControlTypes.label;
+}

package/lib/components/special-label/special-label.module.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./special-label.component";
+import * as i2 from "@ngneat/input-mask";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/input";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/forms";
+import * as i7 from "@angular/material/button";
+import * as i8 from "../../pipes/text-by-function/text-by-function.pipe.module";
+import * as i9 from "../../pipes/error-message-pipe/error.pipe.module";
+export declare class SpecialLabelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialLabelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SpecialLabelModule, [typeof i1.SpecialLabelComponent], [typeof i2.InputMaskModule, typeof i3.CommonModule, typeof i4.MatInputModule, typeof i5.MatIconModule, typeof i6.ReactiveFormsModule, typeof i7.MatButtonModule, typeof i8.TextByFunctionPipeModule, typeof i9.ErrorMessagePipeModule], [typeof i1.SpecialLabelComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SpecialLabelModule>;
+}

package/lib/components/special-multiple-autocomplete/special-multiple-autocomplete.component.d.ts

@@ -0,0 +1,22 @@
+import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import { Subscription } from 'rxjs';
+import { SpecialFormControl } from '../../core/forms/special-forms';
+import { IMultipleAutocompleteSettings } from './special-multiple-autocomplete.interface';
+import { FormControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class SpecialMultipleAutocompleteComponent {
+    control: SpecialFormControl<IMultipleAutocompleteSettings>;
+    subs: Subscription;
+    internalControl: FormControl<any>;
+    constructor();
+    ngOnInit(): void;
+    get settings(): IMultipleAutocompleteSettings;
+    init(): void;
+    optionSelected(data: MatAutocompleteSelectedEvent): void;
+    iconClick(event: any): void;
+    remove(value: any[]): void;
+    configValue: (item: any) => any;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialMultipleAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialMultipleAutocompleteComponent, "sp-multiple-autocomplete", never, { "control": "control"; }, {}, never, never, false>;
+}

package/lib/components/special-multiple-autocomplete/special-multiple-autocomplete.interface.d.ts

@@ -0,0 +1,18 @@
+import { AbstractControl } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { EControlTypes } from '../../core/aux-data/control-types.enum';
+import { IFieldData } from '../../core/interfaces/field-basics.interfaces';
+export declare type IMultipleAutocompleteSettings = {
+    getData: (query: string, control?: AbstractControl) => void;
+    source: Observable<any[]>;
+    fieldId: string;
+    icon?: string;
+    iconAction?: (data: any) => void;
+    onSelect?: (data: any) => void;
+    fieldName: string | ((a?: any) => string);
+    fieldImage?: string | ((a?: any) => string);
+};
+export interface IMultipleAutocompleteField extends IFieldData {
+    settings: IMultipleAutocompleteSettings;
+    type: EControlTypes.multiple;
+}

package/lib/components/special-multiple-autocomplete/special-multiple-autocomplete.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./special-multiple-autocomplete.component";
+import * as i2 from "@angular/material/input";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/autocomplete";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/forms";
+import * as i7 from "@angular/material/button";
+import * as i8 from "../../pipes/error-message-pipe/error.pipe.module";
+import * as i9 from "../../pipes/text-by-function/text-by-function.pipe.module";
+import * as i10 from "@angular/material/chips";
+export declare class SpecialMultipleAutocompleteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialMultipleAutocompleteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SpecialMultipleAutocompleteModule, [typeof i1.SpecialMultipleAutocompleteComponent], [typeof i2.MatInputModule, typeof i3.CommonModule, typeof i4.MatAutocompleteModule, typeof i5.MatIconModule, typeof i6.ReactiveFormsModule, typeof i7.MatButtonModule, typeof i8.ErrorMessagePipeModule, typeof i9.TextByFunctionPipeModule, typeof i10.MatChipsModule], [typeof i1.SpecialMultipleAutocompleteComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SpecialMultipleAutocompleteModule>;
+}

package/lib/components/special-text-area/special-text-area.component.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { SpecialFormControl } from '../../core/forms/special-forms';
+import { ITextAreaField } from './special-text-area.interface';
+import * as i0 from "@angular/core";
+export declare class SpecialTextAreaComponent implements OnInit {
+    control: SpecialFormControl<ITextAreaField>;
+    onBlur: EventEmitter<any>;
+    onEnter: EventEmitter<any>;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialTextAreaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialTextAreaComponent, "sp-text-area", never, { "control": "control"; }, { "onBlur": "onBlur"; "onEnter": "onEnter"; }, never, never, false>;
+}

package/lib/components/special-text-area/special-text-area.interface.d.ts

@@ -0,0 +1,7 @@
+import { EControlTypes } from '../../core/aux-data/control-types.enum';
+import { IFieldData } from '../../core/interfaces/field-basics.interfaces';
+export declare type ITextAreaSettings = {};
+export interface ITextAreaField extends IFieldData {
+    settings: ITextAreaSettings;
+    type: EControlTypes.textArea;
+}

package/lib/components/special-text-area/special-text-area.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./special-text-area.component";
+import * as i2 from "@ngneat/input-mask";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/input";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/forms";
+import * as i7 from "@angular/material/button";
+import * as i8 from "../../pipes/error-message-pipe/error.pipe.module";
+export declare class SpecialTextAreaModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialTextAreaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SpecialTextAreaModule, [typeof i1.SpecialTextAreaComponent], [typeof i2.InputMaskModule, typeof i3.CommonModule, typeof i4.MatInputModule, typeof i5.MatIconModule, typeof i6.ReactiveFormsModule, typeof i7.MatButtonModule, typeof i8.ErrorMessagePipeModule], [typeof i1.SpecialTextAreaComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SpecialTextAreaModule>;
+}

package/lib/components/special-upload/special-upload.component.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { SpecialFormControl } from '../../core/forms/special-forms';
+import { IUploadSettings } from './special-upload.interface';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export declare class SpecialUploadComponent implements OnInit {
+    private sanitizer;
+    control: SpecialFormControl<IUploadSettings>;
+    set controlSetter(control: any);
+    onSelect: EventEmitter<any>;
+    previewImages: any[];
+    constructor(sanitizer: DomSanitizer);
+    ngOnInit(): void;
+    onSelectMultiple(event: any): void;
+    onSelectOne(event: any): void;
+    fixFileName(file: File): File;
+    clean(): void;
+    onRemove(file: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpecialUploadComponent, "sp-upload", never, { "controlSetter": "control"; }, { "onSelect": "onSelect"; }, never, never, false>;
+}

package/lib/components/special-upload/special-upload.interface.d.ts

@@ -0,0 +1,10 @@
+import { EControlTypes } from '../../core/aux-data/control-types.enum';
+import { IFieldData } from '../../core/interfaces/field-basics.interfaces';
+export declare type IUploadSettings = {
+    accept?: string;
+    multiple?: boolean;
+};
+export interface IUploadField extends IFieldData {
+    settings: IUploadSettings;
+    type: EControlTypes.upload;
+}

package/lib/components/special-upload/special-upload.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./special-upload.component";
+import * as i2 from "@angular/forms";
+import * as i3 from "ngx-dropzone";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/material/button";
+import * as i7 from "../../pipes/error-message-pipe/error.pipe.module";
+export declare class SpecialUploadModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialUploadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SpecialUploadModule, [typeof i1.SpecialUploadComponent], [typeof i2.FormsModule, typeof i3.NgxDropzoneModule, typeof i4.CommonModule, typeof i5.MatIconModule, typeof i2.ReactiveFormsModule, typeof i6.MatButtonModule, typeof i7.ErrorMessagePipeModule], [typeof i1.SpecialUploadComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SpecialUploadModule>;
+}

package/lib/core/aux-data/control-types.enum.d.ts

@@ -0,0 +1,16 @@
+export declare enum EControlTypes {
+    pkey = "PRIMARY-KEY",
+    input = "INPUT",
+    textArea = "TEXT-AREA",
+    dropdown = "DROPDOWN",
+    date = "DATE",
+    time = "TIME",
+    checkbox = "CHECKBOX",
+    upload = "UPLOAD",
+    autocomplete = "AUTOCOMPLETE",
+    multiple = "MULTIPLE-AUTOCOMPLETE",
+    array = "ARRAY",
+    form = "FORM",
+    label = "LABEL",
+    default = "DEFAULT"
+}

package/lib/core/forms/special-forms.d.ts

@@ -0,0 +1,110 @@
+import { AbstractControl, FormArray, FormControl, FormGroup } from '@angular/forms';
+import { EControlTypes } from '../aux-data/control-types.enum';
+import { IFieldBasicData } from '../interfaces/field-basics.interfaces';
+import { IArraySettings, IFormSettings, TSpecialFields, TSpecialForm, TSpecialArray } from '../interfaces/form.interfaces';
+export declare class SpecialFormControl<T> extends FormControl implements IFieldBasicData {
+    name: string;
+    placeholder: string;
+    label: string;
+    tooltip: string;
+    icon: string;
+    elementId: string;
+    styleClasses: string;
+    length: number;
+    required: boolean;
+    hidden: boolean;
+    readOnly: boolean;
+    settings: T;
+    type: EControlTypes;
+    errorMessages: {
+        [key: string]: string;
+    };
+    constructor({ name, settings, type, validators, asyncValidators, elementId, styleClasses, defaultValue, hidden, icon, label, length, placeholder, readOnly, required, tooltip, errorMessages, disabled, }: TSpecialFields);
+    setReadOnly(status?: boolean): void;
+    setDisabled(status?: boolean): void;
+    setHidden(status?: boolean): void;
+}
+export declare class SpecialFormGroup extends FormGroup implements IFieldBasicData {
+    name: string;
+    placeholder: string;
+    label: string;
+    tooltip: string;
+    icon: string;
+    elementId: string;
+    styleClasses: string;
+    length: number;
+    required: boolean;
+    hidden: boolean;
+    readOnly: boolean;
+    settings: IFormSettings;
+    type: EControlTypes.form;
+    defaultValue: any;
+    errorMessages: {
+        [key: string]: string;
+    };
+    constructor({ name, settings, type, validators, asyncValidators, elementId, styleClasses, defaultValue, hidden, icon, label, length, placeholder, readOnly, required, tooltip, disabled, }: TSpecialForm, controls: {
+        [key: string]: SpecialFormControl<any>;
+    });
+    unpristineRequired(): void;
+    specialReset(value?: {}): void;
+    setReadOnly(status?: boolean): void;
+    setReadOnlyByFields(fieldsObject: {
+        [key: string]: boolean;
+    }): void;
+    setHiddenByFields(fields: {
+        [key: string]: boolean;
+    }): void;
+    setDisabled(status: boolean): void;
+    setDisabledByFields(fieldsObject: any): void;
+    /**
+     * donde value es el objeto semilla y detailForm es un arreglo de form key para dar un marco al formarray
+     */
+    setFormValue(value: any): void;
+    /**
+     * Método que retorna
+     */
+    getIdPkey(): SpecialFormControl<any> | undefined;
+}
+export declare class SpecialFormArray extends FormArray implements IFieldBasicData {
+    name: string;
+    placeholder: string;
+    label: string;
+    tooltip: string;
+    icon: string;
+    elementId: string;
+    styleClasses: string;
+    required: boolean;
+    hidden: boolean;
+    readOnly: boolean;
+    settings: IArraySettings;
+    type: EControlTypes;
+    defaultValue: any;
+    form: SpecialFormGroup;
+    private formCreation;
+    errorMessages: {
+        [key: string]: string;
+    };
+    constructor({ name, settings, type, validators, asyncValidators, elementId, styleClasses, defaultValue, hidden, icon, label, placeholder, readOnly, required, tooltip, errorMessages, disabled, }: TSpecialArray, formCreation: () => SpecialFormGroup, controls: AbstractControl[]);
+    fillFormArray(data: any[]): void;
+    addItem(): void;
+    specialPush(index?: number): void;
+    specialInsert(index?: number): void;
+    specialEdit(index: number, newValue: Object): void;
+    /**
+     * Vuelve todos los controles del formArray de lectura o de sololectura
+     * @param status
+     */
+    setReadOnly(status: boolean): void;
+    /**
+     * Vuelve todos los controles del formArray habilitados o deshabilitados
+     * @param status
+     */
+    setDisabled(status: boolean): void;
+    /**
+     * Permite editar un control especifico.
+     * @param index
+     */
+    editControl(index: number): void;
+    unpristineRequired(): void;
+    recursiveFillForm(form: FormGroup, data: any): FormGroup;
+}

package/lib/core/interfaces/field-basics.interfaces.d.ts

@@ -0,0 +1,22 @@
+import { AsyncValidatorFn, ValidatorFn } from '@angular/forms';
+export interface IFieldBasicData {
+    placeholder: string;
+    label: string;
+    tooltip: string;
+    icon: string;
+    elementId: string;
+    styleClasses: string;
+    length: number;
+    required: boolean;
+    hidden: boolean;
+    readOnly: boolean;
+    disabled: boolean;
+    errorMessages: {
+        [key: string]: string;
+    };
+}
+export interface IFieldData extends IFieldBasicData {
+    validators: ValidatorFn | ValidatorFn[] | null;
+    asyncValidators: AsyncValidatorFn | AsyncValidatorFn[] | null;
+    defaultValue: any;
+}

package/lib/core/interfaces/form.interfaces.d.ts

@@ -0,0 +1,51 @@
+import { IAutocompleteField } from '../../components/special-autocomplete/special-autocomplete.interface';
+import { IDatePickerField } from '../../components/special-datepicker/special-datepicker.interface';
+import { IDropdownField } from '../../components/special-dropdown/special-dropdown.interface';
+import { IInputField } from '../../components/special-input/special-input.interface';
+import { ICheckboxField } from '../../components/special-checkbox/special-checkbox.interface';
+import { IMultipleAutocompleteField } from '../../components/special-multiple-autocomplete/special-multiple-autocomplete.interface';
+import { EControlTypes } from '../aux-data/control-types.enum';
+import { IFieldData } from './field-basics.interfaces';
+import { ITextAreaField } from '../../components/special-text-area/special-text-area.interface';
+import { IUploadField } from '../../components/special-upload/special-upload.interface';
+import { ILabelField } from '../../components/special-label/special-label.interface';
+interface IcontrolName {
+    name: string;
+}
+export declare type IFormSettings = {
+    formFields: IFormStructure;
+};
+export interface IFormField extends IFieldData {
+    settings: IFormSettings;
+    type: EControlTypes.form;
+}
+export declare type IArraySettings = {
+    formFields: IFormStructure;
+    withFormHeader?: boolean;
+    withActionButtons?: boolean;
+};
+export interface IArrayField extends IFieldData {
+    settings: IArraySettings;
+    type: EControlTypes.array;
+}
+export interface IDefaultField extends IFieldData {
+    settings: any;
+    type: EControlTypes.default;
+}
+export declare type TRawFields = IDefaultField | IInputField | IDropdownField | IArrayField | IFormField | IAutocompleteField | IMultipleAutocompleteField | IDatePickerField | ITextAreaField | IUploadField | ILabelField | ICheckboxField;
+export declare type TSpecialInput = IInputField & IcontrolName;
+export declare type TSpecialDefault = IDefaultField & IcontrolName;
+export declare type TSpecialDropdown = IDropdownField & IcontrolName;
+export declare type TSpecialArray = IArrayField & IcontrolName;
+export declare type TSpecialForm = IFormField & IcontrolName;
+export declare type TSpecialAutocomplete = IAutocompleteField & IcontrolName;
+export declare type TSpecialDatepicker = IDatePickerField & IcontrolName;
+export declare type ISpecialCheckbox = ICheckboxField & IcontrolName;
+export declare type ISpecialTextArea = ITextAreaField & IcontrolName;
+export declare type ISpecialLabel = ILabelField & IcontrolName;
+export declare type ISpecialUpload = IUploadField & IcontrolName;
+export declare type TSpecialFields = TSpecialDefault | TSpecialInput | TSpecialDropdown | TSpecialArray | TSpecialForm | TSpecialAutocomplete | ISpecialCheckbox | ISpecialTextArea | ISpecialUpload | ISpecialLabel | TSpecialDatepicker;
+export interface IFormStructure {
+    [name: string]: Partial<TRawFields>;
+}
+export {};

package/lib/core/services/index.d.ts

@@ -0,0 +1,2 @@
+import { SpecialFormBuilderService } from './special-form-builder/special-form-builder.service';
+export { SpecialFormBuilderService };

package/lib/core/services/special-form-builder/special-form-builder.service.d.ts

@@ -0,0 +1,25 @@
+import { SpecialFormControl, SpecialFormGroup } from '../../forms/special-forms';
+import { IFormStructure, TSpecialFields, TSpecialForm } from '../../interfaces/form.interfaces';
+import * as i0 from "@angular/core";
+export declare class SpecialFormBuilderService {
+    private readonly defectField;
+    private readonly inputDefectField;
+    private readonly formDefectField;
+    private readonly arrayDefectField;
+    constructor();
+    control(field: Partial<TSpecialFields>): SpecialFormControl<any>;
+    group(fields: IFormStructure, parentField?: Partial<TSpecialForm>): SpecialFormGroup;
+    array(): void;
+    fieldDataToArray(fields: IFormStructure): TSpecialFields[];
+    private setDefectFieldOptions;
+    private formGenerator;
+    private getControlAndNameByType;
+    private setFormGroup;
+    private setFormArray;
+    private setFormControl;
+    private setRequiredValidator;
+    private setValidatorsArray;
+    private arrayLengthRequired;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpecialFormBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpecialFormBuilderService>;
+}

package/lib/pipes/controls-list-pipe/controls-list.pipe.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+import { SpecialFormControl } from '../../core/forms/special-forms';
+import * as i0 from "@angular/core";
+export declare class FormControlsListPipe implements PipeTransform {
+    transform(controls: {
+        [key: string]: AbstractControl;
+    }): SpecialFormControl<any>[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormControlsListPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormControlsListPipe, "controlsList", false>;
+}

package/lib/pipes/controls-list-pipe/controls-list.pipe.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./controls-list.pipe";
+import * as i2 from "@angular/common";
+export declare class FormControlsListPipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormControlsListPipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormControlsListPipeModule, [typeof i1.FormControlsListPipe], [typeof i2.CommonModule], [typeof i1.FormControlsListPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormControlsListPipeModule>;
+}

package/lib/pipes/error-message-pipe/error.pipe.d.ts

@@ -0,0 +1,12 @@
+import { PipeTransform } from "@angular/core";
+import { FormControl } from "@angular/forms";
+import * as i0 from "@angular/core";
+export declare class ErrorMessagePipe implements PipeTransform {
+    transform(errorsObj: {
+        [key: string]: any;
+    }, errorMessages: {
+        [key: string]: any;
+    }, control?: FormControl): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorMessagePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ErrorMessagePipe, "errorMessage", false>;
+}

package/lib/pipes/error-message-pipe/error.pipe.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./error.pipe";
+import * as i2 from "@angular/common";
+export declare class ErrorMessagePipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorMessagePipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ErrorMessagePipeModule, [typeof i1.ErrorMessagePipe], [typeof i2.CommonModule], [typeof i1.ErrorMessagePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ErrorMessagePipeModule>;
+}

package/lib/pipes/index.d.ts

@@ -0,0 +1,2 @@
+export { ErrorMessagePipeModule } from './error-message-pipe/error.pipe.module';
+export { TextByFunctionPipeModule } from './text-by-function/text-by-function.pipe.module';

package/lib/pipes/text-by-function/text-by-function.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TextByFunctionPipe implements PipeTransform {
+    transform(value: any, field: string | ((value: any) => string)): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextByFunctionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TextByFunctionPipe, "textByFunction", false>;
+}

package/lib/pipes/text-by-function/text-by-function.pipe.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./text-by-function.pipe";
+import * as i2 from "@angular/common";
+export declare class TextByFunctionPipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextByFunctionPipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TextByFunctionPipeModule, [typeof i1.TextByFunctionPipe], [typeof i2.CommonModule], [typeof i1.TextByFunctionPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TextByFunctionPipeModule>;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "special-forms",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^14.1.0",
+    "@angular/core": "^14.1.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "module": "fesm2015/special-forms.mjs",
+  "es2020": "fesm2020/special-forms.mjs",
+  "esm2020": "esm2020/special-forms.mjs",
+  "fesm2020": "fesm2020/special-forms.mjs",
+  "fesm2015": "fesm2015/special-forms.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2020": "./esm2020/special-forms.mjs",
+      "es2020": "./fesm2020/special-forms.mjs",
+      "es2015": "./fesm2015/special-forms.mjs",
+      "node": "./fesm2015/special-forms.mjs",
+      "default": "./fesm2020/special-forms.mjs"
+    }
+  },
+  "sideEffects": false
+}

package/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/components';
+export * from './lib/core/services/index';