@netgrif/components-core 6.0.1

package/lib/data-fields/models/abstract-data-field-component.d.ts

@@ -0,0 +1,32 @@
+import { DataField } from './abstract-data-field';
+import { FormControl } from '@angular/forms';
+import { OnDestroy, OnInit } from '@angular/core';
+/**
+ * Holds the common functionality for all DataFieldComponents.
+ */
+export declare abstract class AbstractDataFieldComponent implements OnInit, OnDestroy {
+    protected _informAboutInvalidData: boolean | null;
+    /**
+     * The Model object that this Component should render.
+     * It should be overridden in each class that extends this one, to provide a more specific type.
+     */
+    dataField: DataField<any>;
+    taskOffset: number;
+    /**
+     * @ignore
+     * See [formControl]{@link AbstractDataFieldComponent#formControl}
+     */
+    protected _formControl: FormControl;
+    protected constructor(_informAboutInvalidData: boolean | null);
+    /**
+     * Registers the {@link FormControl} to the provided data field.
+     *
+     * See [DataField.registerFormControl]{@link DataField#registerFormControl} form more information.
+     */
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * The [FormControl]{@link https://angular.io/api/forms/FormControl} object that should be used to control any rendered forms.
+     */
+    get formControl(): FormControl;
+}

package/lib/data-fields/models/abstract-data-field.d.ts

@@ -0,0 +1,220 @@
+import { Behavior } from './behavior';
+import { BehaviorSubject, Observable, Subject, Subscription } from 'rxjs';
+import { FormControl, ValidatorFn } from '@angular/forms';
+import { Change } from './changed-fields';
+import { Layout } from './layout';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { Component } from './component';
+import { Validation } from './validation';
+/**
+ * Holds the logic common to all data field Model objects.
+ * @typeparam T - type of the `value` property of the data field
+ */
+export declare abstract class DataField<T> {
+    private _stringId;
+    private _title;
+    private _behavior;
+    private _placeholder?;
+    private _description?;
+    private _layout?;
+    validations?: Array<Validation>;
+    private _component?;
+    private _parentTaskId?;
+    private _parentCaseId?;
+    /**
+     * @ignore
+     * Current value of the data field
+     */
+    protected _value: BehaviorSubject<T>;
+    /**
+     * @ignore
+     * Previous value of the data field
+     */
+    protected _previousValue: BehaviorSubject<T>;
+    /**
+     * @ignore
+     * Whether the data field Model object was initialized, we push that info into stream
+     *
+     * See [registerFormControl()]{@link DataField#registerFormControl} for more information.
+     */
+    protected _initialized$: BehaviorSubject<boolean>;
+    /**
+     * @ignore
+     * Whether the field fulfills all of it's validators.
+     */
+    private _valid;
+    /**
+     * @ignore
+     * Whether the `value` of the field changed recently. The flag is cleared when changes are send to backend.
+     */
+    private _changed;
+    /**
+     * @ignore
+     * Data field subscribes this stream.
+     * The data field updates it's Validators, validity and enabled/disabled according to it's behavior.
+     */
+    protected _update: Subject<void>;
+    /**
+     * @ignore
+     * Data field subscribes this stream. When a `true` value is received the data field disables itself.
+     * When a `false`value is received data field disables/enables itself based on it's behavior.
+     */
+    protected _block: Subject<boolean>;
+    /**
+     * @ignore
+     * When a `true` value is there, the data field is disabled.
+     * When a `false` value is received, data field is disabled/enabled based on it's behavior.
+     */
+    protected _blocked: boolean;
+    /**
+     * @ignore
+     * Data field subscribes this stream. Sets the state of the data field to "touched" or "untouched" (`true`/`false`).
+     * Validity of the data field is not checked in an "untouched" state.
+     * All fields are touched before a task is finished to check their validity.
+     */
+    protected _touch: Subject<boolean>;
+    protected _updateSubscription: Subscription;
+    protected _blockSubscription: Subscription;
+    protected _touchSubscription: Subscription;
+    protected _formControlValueSubscription: Subscription;
+    protected _myValueSubscription: Subscription;
+    /**
+     * @ignore
+     * Appearance of dataFields, possible values - outline, standard, fill, legacy
+     */
+    materialAppearance: string;
+    /**
+     * @ignore
+     * Whether the field fulfills required validator.
+     */
+    private _validRequired;
+    /**
+     * Whether invalid field values should be sent to backend.
+     */
+    private _sendInvalidValues;
+    /**
+     * Flag that is set during reverting
+     */
+    private _reverting;
+    /**
+     * Validators resolved from field validations
+     */
+    protected _validators: Array<ValidatorFn>;
+    /**
+     * Stores the last subscription to the [_initialized$]{@link AbstractDataField#_initialized$} Stream, to prevent multiple block events
+     * from executing at the same time
+     */
+    protected _initializedSubscription: Subscription;
+    /**
+     * @ignore
+     * Whether the changes from has been requested. The flag is cleared when changes are received from backend.
+     */
+    private _waitingForResponse;
+    /**
+     * Stores a copy of the fields layout, that can be modified by the layouting algorithm as needed
+     * without affecting the base configuration.
+     */
+    protected _localLayout: Layout;
+    /**
+     * @param _stringId - ID of the data field from backend
+     * @param _title - displayed title of the data field from backend
+     * @param initialValue - initial value of the data field
+     * @param _behavior - data field behavior
+     * @param _placeholder - placeholder displayed in the datafield
+     * @param _description - tooltip of the datafield
+     * @param _layout - information regarding the component rendering
+     * @param validations
+     * @param _component - component data of datafield
+     * @param _parentTaskId - stringId of parent task, only defined if field is loaded using {@link TaskRefField}
+     * @param _parentCaseId - stringId of parent case, only defined if field is loaded using {@link TaskRefField}
+     */
+    protected constructor(_stringId: string, _title: string, initialValue: T, _behavior: Behavior, _placeholder?: string, _description?: string, _layout?: Layout, validations?: Array<Validation>, _component?: Component, _parentTaskId?: string, _parentCaseId?: string);
+    get stringId(): string;
+    set title(title: string);
+    get title(): string;
+    set placeholder(placeholder: string);
+    get placeholder(): string;
+    set description(desc: string);
+    get description(): string;
+    set behavior(behavior: Behavior);
+    get behavior(): Behavior;
+    get value(): T;
+    set value(value: T);
+    get parentTaskId(): string;
+    get parentCaseId(): string;
+    get previousValue(): T;
+    set previousValue(value: T);
+    valueWithoutChange(value: T): void;
+    set layout(layout: Layout);
+    get layout(): Layout;
+    get localLayout(): Layout;
+    get disabled(): boolean;
+    get initialized(): boolean;
+    get initialized$(): Observable<boolean>;
+    set valid(set: boolean);
+    get valid(): boolean;
+    set changed(set: boolean);
+    get changed(): boolean;
+    set block(set: boolean);
+    set touch(set: boolean);
+    get component(): Component;
+    revertToPreviousValue(): void;
+    set validRequired(set: boolean);
+    get validRequired(): boolean;
+    get sendInvalidValues(): boolean;
+    set sendInvalidValues(value: boolean | null);
+    get waitingForResponse(): boolean;
+    set waitingForResponse(value: boolean);
+    update(): void;
+    valueChanges(): Observable<T>;
+    set reverting(set: boolean);
+    get reverting(): boolean;
+    destroy(): void;
+    registerFormControl(formControl: FormControl): void;
+    disconnectFormControl(): void;
+    protected updateFormControlState(formControl: FormControl): void;
+    protected subscribeToInnerSubjects(formControl: FormControl): void;
+    /**
+     * Computes whether the FormControl si valid.
+     * @param formControl check form control
+     */
+    protected _determineFormControlValidity(formControl: FormControl): boolean;
+    /**
+     * Creates Validator objects based on field `behavior`. Only the `required` behavior is resolved by default.
+     * Required is resolved as `Validators.required`.
+     * If you need to resolve additional Validators or need a different resolution for the `required` Validator override this method.
+     *
+     * See {@link Behavior} for information about data field behavior.
+     *
+     * See {@link ValidatorFn} and {@link Validators} for information about Validators.
+     *
+     * Alternatively see [Form Validation guide]{@link https://angular.io/guide/form-validation#reactive-form-validation} from Angular.
+     */
+    protected resolveFormControlValidators(): Array<ValidatorFn>;
+    replaceValidations(validations: Array<Validation>): void;
+    clearValidators(): void;
+    protected resolveValidations(): Array<ValidatorFn>;
+    /**
+     * Determines if two values of the data field are equal.
+     *
+     * `a === b` equality is used by default. If you want different behavior override this method.
+     * @param a - first compared value
+     * @param b - second compared value
+     */
+    protected valueEquality(a: T, b: T): boolean;
+    /**
+     * Updates the state of this data field model object.
+     * @param change - object describing the changes - returned from backend
+     *
+     * Also see {@link ChangedFields}.
+     */
+    applyChange(change: Change): void;
+    resolveAppearance(config: ConfigurationService): void;
+    resolvePrevValue(value: T): void;
+    protected calculateValidity(forValidRequired: boolean, formControl: FormControl): boolean;
+    isInvalid(formControl: FormControl): boolean;
+    /**
+     * Copies the layout settings into the local layout.
+     */
+    resetLocalLayout(): void;
+}

package/lib/data-fields/models/behavior.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Describes the behavior of data fields.
+ *
+ * `required` is mutually exclusive with `optional`.
+ *
+ * `visible`, `editable`, `hidden` and `forbidden` are mutually exclusive with each other.
+ */
+export interface Behavior {
+    /**
+     * The data field's value must be filled and valid in order to finish a task.
+     */
+    required?: boolean;
+    /**
+     * Opposite of `required`.
+     *
+     * See [required]{@link Behavior#required}.
+     */
+    optional?: boolean;
+    /**
+     * The data field's value is visible to the user, but they cannot change it.
+     * Data field Components that render such field are set to `disabled`.
+     */
+    visible?: boolean;
+    /**
+     * The value of the data field can be changed.
+     * Data field Components that render such field are set to `enabled`.
+     */
+    editable?: boolean;
+    /**
+     * Information about the data field should not be displayed to the user.
+     * Data field Components that render such field are removed from DOM.
+     */
+    hidden?: boolean;
+    /**
+     * Forbidden implies that information about this datafield should not be sent to frontend.
+     * Fields with this behavior set to `true` can be only received in the {@link ChangedFields} object, when a field that wasn't previously
+     * marked as `forbidden` had it's behavior changed.
+     */
+    forbidden?: boolean;
+}

package/lib/data-fields/models/boolean-label-enabled-token.d.ts

@@ -0,0 +1,2 @@
+import { InjectionToken } from '@angular/core';
+export declare const BOOLEAN_VALUE_LABEL_ENABLED: InjectionToken<boolean>;

package/lib/data-fields/models/changed-fields.d.ts

@@ -0,0 +1,44 @@
+import { Behavior } from './behavior';
+/**
+ * response example:
+ *  {"changedFields": {
+ *      "text_1":{"behavior":{"1":{"editable":true}}},
+ *     "text_0":{"behavior":{"1":{"visible":true}}},
+ *      "text_3":{"behavior":{"1":{"editable":true,"optional":true}}},
+ *      "text_2":{"behavior":{"1":{"editable":true,"required":true}}},
+ *      "text_5":{"behavior":{"1":{"forbidden":true}}},
+ *      "text_4":{"behavior":{"1":{"hidden":true}}}
+ *  }}
+ *
+ *  1 ==> transition ID
+ *
+ *  it might be better if some parent element gave only the relevant changes to each task
+ */
+export interface ChangedFields {
+    /**
+     * `StringId` of the `Task` that "owns" the requested frontend actions
+     */
+    frontendActionsOwner?: string;
+    /**
+     * Has type `Change` unless it is `frontendActionsOwner` in which case the type is `string`
+     */
+    [key: string]: Change | any;
+    /**
+     * Id of task on which the changes occured
+     */
+    taskId?: string;
+}
+export interface Change {
+    value?: string | number | boolean | any;
+    type?: string;
+    behavior?: {
+        [key: string]: Behavior;
+    };
+    [key: string]: any;
+}
+/**
+ * A prototype implementation of frontend actions.
+ *
+ * The specifics are subject to change.
+ */
+export declare type FrontendActions = Change;

package/lib/data-fields/models/component.d.ts

@@ -0,0 +1,7 @@
+import { Properties } from './properties';
+import { Icon } from './icon';
+export interface Component {
+    name: string;
+    properties?: Properties;
+    optionIcons?: Array<Icon>;
+}

package/lib/data-fields/models/format-filter.d.ts

@@ -0,0 +1,5 @@
+export interface FormatFilter {
+    code: string;
+    fractionSize: number;
+    locale: string;
+}

package/lib/data-fields/models/icon.d.ts

@@ -0,0 +1,9 @@
+export interface Icon {
+    key: string;
+    type: string;
+    value: string;
+}
+export declare enum IconType {
+    MATERIAL = "material",
+    SVG = "svg"
+}

package/lib/data-fields/models/invalid-data-policy-token.d.ts

@@ -0,0 +1,10 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Whether invalid data values should be sent to backend or not. Invalid data is NOT set to backend by default.
+ * You can use this InjectionToken to override this behavior in a specific application scope.
+ *
+ * This token is ultimately injected by individual data fields, so this option can be in theory applied at a very low level of granularity.
+ * The library implementation doesn't allow access to such low level components, so a custom implementation is necessary to provide this
+ * token at such low level. Applying the token to individual task views is achievable with the default implementation.
+ */
+export declare const NAE_INFORM_ABOUT_INVALID_DATA: InjectionToken<boolean>;

package/lib/data-fields/models/layout.d.ts

@@ -0,0 +1,22 @@
+import { GridLayout } from '../../utility/grid-layout/model/grid-element';
+import { TemplateAppearance } from './template-appearance';
+import { MaterialAppearance } from './material-appearance';
+import { FieldAlignment } from '../../resources/interface/field-alignment';
+/**
+ * Layout information for the data field.
+ */
+export interface Layout extends GridLayout {
+    /**
+     * Determines how much space the form field occupies.
+     */
+    template: TemplateAppearance;
+    /**
+     * Determines the appearance of the form field.
+     */
+    appearance: MaterialAppearance;
+    offset: number;
+    /**
+     * Determines the vertical alignment of the field within its designated space
+     */
+    alignment?: FieldAlignment;
+}

package/lib/data-fields/models/material-appearance.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Appearance of rendered material form field.
+ *
+ * See [Material documentation]{@link https://material.angular.io/components/form-field/overview#form-field-appearance-variants}
+ * for more information.
+ */
+export declare enum MaterialAppearance {
+    LEGACY = "legacy",
+    STANDARD = "standard",
+    FILL = "fill",
+    OUTLINE = "outline"
+}

package/lib/data-fields/models/properties.d.ts

@@ -0,0 +1,3 @@
+export interface Properties {
+    [key: string]: any;
+}

package/lib/data-fields/models/template-appearance.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Preferred layout of the displayed data field.
+ *
+ * `MATERIAL` - displays the material form field at 100% width of the available space.
+ *
+ * `NETGRIF` - displays the field at 100% width if the total width is bellow a given threshold (by default 250px).
+ * Displays the field title on the left and the form filed on the right sharing the width 50:50 otherwise.
+ * The form filed still uses material design with this setting.
+ */
+export declare enum TemplateAppearance {
+    MATERIAL = "material",
+    NETGRIF = "netgrif"
+}

package/lib/data-fields/models/validation.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Contains field validation information from backend.
+ */
+export interface Validation {
+    /**
+     * Value set in the PetriNet model as validation.
+     */
+    validationRule: string;
+    /**
+     * Message that should be displayed when the validation fails.
+     *
+     * If the message is empty, some default message will be displayed.
+     */
+    validationMessage: string;
+}

package/lib/data-fields/multichoice-field/abstract-multichoice-field.component.d.ts

@@ -0,0 +1,6 @@
+import { MultichoiceField } from './models/multichoice-field';
+import { AbstractDataFieldComponent } from '../models/abstract-data-field-component';
+export declare abstract class AbstractMultichoiceFieldComponent extends AbstractDataFieldComponent {
+    dataField: MultichoiceField;
+    protected constructor(informAboutInvalidData: boolean | null);
+}

package/lib/data-fields/multichoice-field/models/multichoice-field.d.ts

@@ -0,0 +1,26 @@
+import { DataField } from '../../models/abstract-data-field';
+import { Behavior } from '../../models/behavior';
+import { Layout } from '../../models/layout';
+import { FieldTypeResource } from '../../../task-content/model/field-type-resource';
+import { Component } from '../../models/component';
+import { Validation } from '../../models/validation';
+export interface MultichoiceFieldValue {
+    key: string;
+    value: string;
+}
+export declare enum MultichoiceFieldView {
+    DEFAULT = "default",
+    LIST = "list"
+}
+export declare class MultichoiceField extends DataField<Array<string>> {
+    private _choices;
+    private _view;
+    private readonly _fieldType;
+    constructor(stringId: string, title: string, values: Array<string>, _choices: Array<MultichoiceFieldValue>, behavior: Behavior, placeholder?: string, description?: string, layout?: Layout, _view?: MultichoiceFieldView, _fieldType?: FieldTypeResource, validations?: Array<Validation>, component?: Component, parentTaskId?: string);
+    set choices(choices: Array<MultichoiceFieldValue>);
+    get choices(): Array<MultichoiceFieldValue>;
+    set view(view: MultichoiceFieldView);
+    get view(): MultichoiceFieldView;
+    get fieldType(): FieldTypeResource;
+    protected valueEquality(a: Array<string>, b: Array<string>): boolean;
+}

package/lib/data-fields/multichoice-field/multichoice-list-field/abstract-multichoice-list-field.component.d.ts

@@ -0,0 +1,10 @@
+import { MultichoiceField } from '../models/multichoice-field';
+import { FormControl } from '@angular/forms';
+import { WrappedBoolean } from '../../data-field-template/models/wrapped-boolean';
+export declare abstract class AbstractMultichoiceListFieldComponent {
+    multichoiceField: MultichoiceField;
+    formControlRef: FormControl;
+    showLargeLayout: WrappedBoolean;
+    selected: Array<string>;
+    validate: FormControl;
+}

package/lib/data-fields/multichoice-field/multichoice-select-field/abstract-multichoice-select-field.component.d.ts

@@ -0,0 +1,8 @@
+import { MultichoiceField } from '../models/multichoice-field';
+import { FormControl } from '@angular/forms';
+import { WrappedBoolean } from '../../data-field-template/models/wrapped-boolean';
+export declare abstract class AbstractMultichoiceSelectFieldComponent {
+    multichoiceField: MultichoiceField;
+    formControlRef: FormControl;
+    showLargeLayout: WrappedBoolean;
+}

package/lib/data-fields/number-field/abstract-number-errors.component.d.ts

@@ -0,0 +1,13 @@
+import { NumberField } from './models/number-field';
+import { TranslateService } from '@ngx-translate/core';
+import { FormControl } from '@angular/forms';
+import { WrappedBoolean } from '../data-field-template/models/wrapped-boolean';
+export declare abstract class AbstractNumberErrorsComponent {
+    protected _translate: TranslateService;
+    showLargeLayout: WrappedBoolean;
+    formControlRef: FormControl;
+    numberField: NumberField;
+    protected constructor(_translate: TranslateService);
+    getErrorMessage(): any;
+    resolveErrorMessage(search: string, generalMessage: string): string;
+}

package/lib/data-fields/number-field/abstract-number-field.component.d.ts

@@ -0,0 +1,8 @@
+import { NumberField } from './models/number-field';
+import { AbstractDataFieldComponent } from '../models/abstract-data-field-component';
+import { TranslateService } from '@ngx-translate/core';
+export declare abstract class AbstractNumberFieldComponent extends AbstractDataFieldComponent {
+    protected _translate: TranslateService;
+    dataField: NumberField;
+    protected constructor(_translate: TranslateService, informAboutInvalidData: boolean | null);
+}

package/lib/data-fields/number-field/currency-number-field/abstract-currency-number-field.component.d.ts

@@ -0,0 +1,15 @@
+import { OnInit } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { CurrencyPipe } from '@angular/common';
+import { AbstractNumberErrorsComponent } from '../abstract-number-errors.component';
+export declare abstract class AbstractCurrencyNumberFieldComponent extends AbstractNumberErrorsComponent implements OnInit {
+    protected _currencyPipe: CurrencyPipe;
+    transformedValue: string;
+    fieldType: string;
+    protected constructor(_currencyPipe: CurrencyPipe, translateService: TranslateService);
+    ngOnInit(): void;
+    transformToText(event: Event): void;
+    transformToNumber(): void;
+    getCurrencySymbol(): string;
+    private transformCurrency;
+}

package/lib/data-fields/number-field/models/number-field.d.ts

@@ -0,0 +1,36 @@
+import { Behavior } from '../../models/behavior';
+import { ValidatorFn } from '@angular/forms';
+import { Layout } from '../../models/layout';
+import { Validation } from '../../models/validation';
+import { FormatFilter } from '../../models/format-filter';
+import { Component } from '../../models/component';
+import { DataField } from '../../models/abstract-data-field';
+export declare enum NumberFieldValidation {
+    ODD = "odd",
+    EVEN = "even",
+    POSITIVE = "positive",
+    NEGATIVE = "negative",
+    DECIMAL = "decimal",
+    IN_RANGE = "inrange",
+    INF = "inf",
+    REQUIRED = "required",
+    VALID_ODD = "validOdd",
+    VALID_EVEN = "validEven",
+    VALID_POSITIVE = "validPositive",
+    VALID_NEGATIVE = "validNegative",
+    VALID_DECIMAL = "validDecimal",
+    VALID_IN_RANGE = "validInRange"
+}
+export declare class NumberField extends DataField<number> {
+    _formatFilter: FormatFilter;
+    constructor(stringId: string, title: string, value: number, behavior: Behavior, validations?: Array<Validation>, placeholder?: string, description?: string, layout?: Layout, format?: FormatFilter, component?: Component, parentTaskId?: string);
+    protected resolveValidations(): Array<ValidatorFn>;
+    private validOdd;
+    private validEven;
+    private validPositive;
+    private validNegative;
+    private validDecimal;
+    private validInRangeSmaller;
+    private validInRangeBigger;
+    private validInRange;
+}

package/lib/data-fields/number-field/number-default-field/abstract-default-number-field.component.d.ts

@@ -0,0 +1,5 @@
+import { TranslateService } from '@ngx-translate/core';
+import { AbstractNumberErrorsComponent } from '../abstract-number-errors.component';
+export declare abstract class AbstractDefaultNumberFieldComponent extends AbstractNumberErrorsComponent {
+    protected constructor(translateService: TranslateService);
+}