@beinformed/ui 1.59.21 → 1.59.23

package/lib/models/filters/BaseFilterModel.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Base class for filters
+ */
+export default class BaseFilterModel extends BaseModel {
+    _attribute: AttributeType | null;
+    _context: Object;
+    _listKey: string;
+    /**
+     * Set key of list this filter belongs to
+     */
+    set listkey(key: string);
+    /**
+     * Getting key of the list these filters apply to
+     */
+    get listkey(): string;
+    /**
+     * Get the type of a filter.
+     */
+    get type(): string;
+    /**
+     * Create attribute through the attribute factory. Create type based on filter key without the filter suffix
+     */
+    createAttribute(type: string, param: string, data: Object, contributions: Object): AttributeType | null;
+    /**
+     * Inidiates if filter is multiplechoice
+     */
+    get isMultiple(): boolean;
+    /**
+     * Set context of filter
+     */
+    set context(context: Object);
+    /**
+     * Getting context data
+     */
+    get context(): Object;
+    /**
+     * Getting the context label
+     */
+    get contextLabel(): string;
+    /**
+     * Getting the label of the filter
+     */
+    get label(): string;
+    /**
+     * Getting the name of the filter
+     */
+    get name(): string;
+    /**
+     * Getting the param name of the filter
+     */
+    get param(): string;
+    /**
+     * Get attribute of filter
+     */
+    get attribute(): AttributeType;
+    /**
+     * Retrieve the parameters with it's value for this filter
+     */
+    get params(): Array<{
+        name: string;
+        value: string | null;
+    }>;
+    /**
+     * Getting the value of the filter
+     */
+    get value(): string | null;
+    /**
+     * Getting the inputvalue of the filter
+     */
+    get inputvalue(): string;
+    /**
+     * Reset the value of this filter to undefined
+     */
+    reset(): FilterType;
+    /**
+     * Update this filter with input name and value
+     */
+    update(attribute: AttributeType, value: string): void;
+    /**
+     * Inidicates if filter is a quick search filter
+     */
+    isQuickSearch(): boolean;
+    /**
+     * Inidiates if filter is active
+     */
+    isActive(): boolean;
+    /**
+     * Inidiates if filter is valid
+     */
+    get isValid(): boolean;
+    /**
+     */
+    get readonlyvalue(): string;
+    /**
+     * Get assistant message
+     */
+    get assistantMessage(): string | null;
+}
+import BaseModel from "../base/BaseModel";
+import { AttributeType } from "../types";
+import { FilterType } from "../types";

package/lib/models/filters/ConceptIndexFilterModel.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The concept index model is a special filter used to index all first concept label letters in de modelcatalog.
+ */
+export default class ConceptIndexFilterModel extends BaseFilterModel {
+}
+import BaseFilterModel from "../filters/BaseFilterModel";

package/lib/models/filters/FilterCollection.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Contains a collection of filters
+ */
+export default class FilterCollection extends BaseCollection<FilterType> {
+    /**
+     * Construct a collection of filters
+     */
+    constructor(data?: Object, contributions?: Object, modelOptions?: ModelOptions);
+    collection: any;
+    /**
+     */
+    createFilter(filterKey: string, data: Object, contributions: Object, modelOptions?: ModelOptions): FilterType;
+    /**
+     * Call the reset function on all filters
+     *
+     * @see {FilterType#reset()}
+     */
+    reset(): FilterCollection;
+    /**
+     * Checks if range attribute key equals key
+     */
+    checkRangeFilterByAttributeKey(filter: RangeFilterModel, key: string): boolean;
+    /**
+     * Check if assignment filter attribute matches key
+     */
+    checkAssignmentFilterByAttributeKey(filter: AssignmentFilterModel, key: string): boolean;
+    /**
+     * Getting the filter by name
+     */
+    getFilterByAttributeKey(key: string): FilterType | null;
+    /**
+     * Update Filter by input name and value
+     */
+    update(attribute: AttributeType, value: string): void;
+    /**
+     * Retrieve if all filters are valid
+     */
+    get isValid(): boolean;
+    /**
+     * Indicates if an active filter is present in the collection
+     */
+    hasActiveFilters(): boolean;
+}
+import { FilterType } from "../types";
+import BaseCollection from "../base/BaseCollection";
+import { ModelOptions } from "../types";
+import RangeFilterModel from "../filters/RangeFilterModel";
+import AssignmentFilterModel from "../filters/AssignmentFilterModel";
+import { AttributeType } from "../types";

package/lib/models/filters/FilterModel.d.ts

@@ -0,0 +1,5 @@
+/**
+ */
+export default class FilterModel extends BaseFilterModel {
+}
+import BaseFilterModel from "../filters/BaseFilterModel";

package/lib/models/filters/RangeFilterModel.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Range filter, for instance a date range filter or a number range filter
+ */
+export default class RangeFilterModel extends BaseFilterModel {
+}
+import BaseFilterModel from "../filters/BaseFilterModel";

package/lib/models/filters/StringFilterModel.d.ts

@@ -0,0 +1,30 @@
+/**
+ * StringFilterModel can handle string filters with multiple setting
+ */
+export default class StringFilterModel extends FilterModel {
+    _isValid: boolean;
+    _value: string | null;
+    _inputvalue: string;
+    /**
+     */
+    get operator(): string;
+    /**
+     */
+    formatValue(value: string): string;
+    /**
+     */
+    isBSN(): boolean;
+    /**
+     */
+    isIBAN(): boolean;
+    /**
+     */
+    isZipcode(): boolean;
+    /**
+     */
+    removeFormat(value: string | null): string;
+    /**
+     */
+    shouldHandleFormat(): boolean;
+}
+import FilterModel from "./FilterModel";

package/lib/models/form/FormModel.d.ts

@@ -0,0 +1,350 @@
+export default FormModel;
+/**
+ */
+declare class FormModel extends ResourceModel {
+    /**
+     */
+    constructor(modularuiResponse: ModularUIResponse);
+    _lastUpdate: number;
+    _completedFormObjects: Array<FormObjectModel>;
+    _currentFormObject: FormObjectModel | null;
+    _previouslyEnteredFormObjects: Array<FormObjectModel>;
+    _mergePreviouslyEnteredObjects: boolean;
+    _endResultFormObjects: Array<FormObjectModel>;
+    _previousEndResultKeys: Array<string>;
+    _useClientsideValidation: boolean;
+    _errorCollection: ErrorCollection;
+    _redirectLocation: Href;
+    _commit: boolean;
+    _isFinished: boolean;
+    _isComplete: boolean;
+    _success: {
+        redirect: string;
+        data: Object;
+    } | null;
+    _parameters: Array<Parameter>;
+    _tokens: Array<string>;
+    /**
+     */
+    set lastUpdate(lastUpdate: number);
+    /**
+     */
+    get lastUpdate(): number;
+    /**
+     */
+    set currentFormObject(formObject: FormObjectModel | null);
+    /**
+     */
+    get currentFormObject(): FormObjectModel | null;
+    /**
+     */
+    set endResultFormObjects(endResultFormObjects: Array<FormObjectModel>);
+    /**
+     */
+    get endResultFormObjects(): Array<FormObjectModel>;
+    /**
+     */
+    set parameters(parameters: Array<Parameter>);
+    /**
+     */
+    get parameters(): Array<Parameter>;
+    /**
+     */
+    set isComplete(isComplete: boolean);
+    /**
+     * Indicates if form is completely entered
+     */
+    get isComplete(): boolean;
+    /**
+     */
+    get actiontype(): string;
+    /**
+     * Get form level button labels
+     */
+    get buttonLabels(): Object;
+    /**
+     * @returns button label from contributions;
+     */
+    getButtonLabel(buttonType: "cancel" | "previous" | "next" | "finish"): string | null;
+    /**
+     * Get all applicable objects
+     */
+    get allObjects(): Array<FormObjectModel>;
+    /**
+     */
+    get objectKeys(): Array<string>;
+    /**
+     */
+    get numberOfExpectedQuestions(): number;
+    /**
+     * Has questions configured on form
+     */
+    get hasNoQuestionsConfigured(): boolean;
+    /**
+     */
+    addGlobalDynamicSchema(anchor: Object, dynamicschema: Object): Object;
+    /**
+     */
+    getMissingAnchors(): Array<Object>;
+    /**
+     * Create form object based on the data and contributions available in this form
+     */
+    createFormObject(): FormObjectModel | null;
+    /**
+     */
+    addEmptyFormObject(formObjectModel?: FormObjectModel | null): void;
+    /**
+     */
+    getHighestRepeatIndex(formObjectModel: FormObjectModel): number;
+    /**
+     */
+    addFormObject(formObjectModel: FormObjectModel): void;
+    /**
+     */
+    set completedFormObjects(formObjects: Array<FormObjectModel>);
+    /**
+     * Completed objects are previously entered questions
+     */
+    get completedFormObjects(): Array<FormObjectModel>;
+    /**
+     * Retrieve a form object by the key
+     */
+    getFormObjectByKey(key: string): FormObjectModel | null;
+    /**
+     * Retrieve a form object by a layouthint
+     */
+    getFormObjectByLayoutHint(hint: string): FormObjectModel | null;
+    /**
+     */
+    removeFormObject(formObjectModel: FormObjectModel | null): void;
+    /**
+     */
+    set previouslyEnteredFormObjects(formObjects: Array<FormObjectModel>);
+    /**
+     * Previously entered objects are questions that have been entered before,
+     * but are currently not applicable for the form.
+     * For example because of previous navigation
+     */
+    get previouslyEnteredFormObjects(): Array<FormObjectModel>;
+    /**
+     * Handle end results
+     */
+    setEndResultFormObjects(): Array<FormObjectModel>;
+    /**
+     */
+    get expectsEndResultFormObjects(): boolean;
+    /**
+     */
+    getEndResultFormObjects(): Array<FormObjectModel>;
+    /**
+     */
+    set previousEndResultKeys(endResultFormObjectKeys: Array<string>);
+    /**
+     */
+    get previousEndResultKeys(): Array<string>;
+    /**
+     * Error handling
+     */
+    get isValid(): boolean;
+    /**
+     */
+    hasServerErrors(): boolean;
+    /**
+     */
+    hasErrors(): boolean;
+    /**
+     * Add an error to the error collection of this form
+     */
+    addServerError(error: ErrorResponse): void;
+    /**
+     * Reset error messages
+     */
+    resetErrors(): void;
+    /**
+     */
+    set errorCollection(errorCollection: ErrorCollection);
+    /**
+     */
+    get errorCollection(): ErrorCollection;
+    /**
+     */
+    set commit(commit: boolean);
+    /**
+     * Indicates if the form needs to be committed
+     */
+    get commit(): boolean;
+    /**
+     */
+    set isFinished(isFinished: boolean);
+    /**
+     * Inidicates if form is finished: Form is completely entered and committed
+     */
+    get isFinished(): boolean;
+    /**
+     * Handle success redirects
+     */
+    get successRedirect(): Href | null;
+    /**
+     */
+    get redirectLocation(): Href;
+    /**
+     * Get the result data as plain json object
+     */
+    getSuccessData(): Object | null;
+    /**
+     * Retrieve an object where each property is a result data attribute set
+     */
+    getResultData(): {
+        [key: string]: AttributeSetModel;
+    } | null;
+    /**
+     */
+    get resultData(): Object | null;
+    /**
+     * Href handling
+     */
+    setParameters(modularuiResponse: ModularUIResponse): Array<Parameter>;
+    /**
+     */
+    selfhrefNoCommitParam(): Href;
+    /**
+     */
+    selfhrefWithCommitParam(): Href;
+    /**
+     * Replaces all tokens with the given collection of tokens
+     */
+    set tokens(tokens: Array<string>);
+    /**
+     * Handle form tokens to indicate concurrent form use
+     */
+    get tokens(): Array<string>;
+    /**
+     * Removes all tokens from the form
+     */
+    removeTokens(): void;
+    /**
+     * Keep track of changed form
+     */
+    isChanged(): boolean;
+    /**
+     */
+    getFormDataObjects(validOnly?: boolean, validationData?: boolean): Array<Object>;
+    /**
+     */
+    getFormData(validOnly?: boolean, withConcurrencyToken?: boolean, validationData?: boolean): string;
+    /**
+     * Used to programmatically overwrite the setting USE_CLIENTSIDE_VALIDATION
+     */
+    setUseClientsideValidation(enabled: boolean): void;
+    /**
+     * Indicates if client side validation is enabled
+     * @returns {boolean}
+     */
+    useClientsideValidation(): boolean;
+    /**
+     * Get form data for submitting
+     */
+    get formdata(): string;
+    /**
+     */
+    get validationData(): string;
+    /**
+     * Form navigation: Go one object back (previous button)
+     */
+    get hasPreviousStep(): boolean;
+    /**
+     * Go one form-object back,
+     * for repeating object this means go back
+     * until we get at a form object that had
+     * a different key than the current form object
+     */
+    setPreviousObject(): void;
+    /**
+     * Set success information, contains redirect and event data
+     * @param success
+     */
+    set success(success: {
+        redirect: string;
+        data: Object;
+    } | null);
+    /**
+     * Retrieve success information from response
+     * @returns {{redirect: string, data: object}}
+     */
+    get success(): {
+        redirect: string;
+        data: Object;
+    } | null;
+    /**
+     * Form navigation: has next step or is last
+     */
+    get hasNextStep(): boolean;
+    /**
+     * Merge existing form with new form
+     */
+    update(receivedForm: ModularUIModel): FormModel;
+    /**
+     * Updates the current form object with new information about the object,
+     * like for example a new dynamicschema. Used for autoupdate functionality that makes it possible
+     * to update the options of a next missing attribute in a form-tree iq question
+     */
+    updateCurrentFormObject(receivedForm: ModularUIModel): void;
+    /**
+     */
+    updateValidations(data: any): FormModel;
+    /**
+     */
+    createSuccess(): void;
+    /**
+     * Process finished form
+     */
+    handleFinished(receivedForm: FormModel): void;
+    /**
+     */
+    handleRootErrors(errors: Array<Object>): void;
+    /**
+     * Process errors from received form
+     */
+    handleErrors(receivedForm: FormModel): void;
+    /**
+     * Process missing from received form
+     */
+    handleMissing(receivedForm: FormModel): void;
+    /**
+     * Received missing anchors in the response with an object id that is the current form object
+     */
+    processMissingErrors(receivedForm: FormModel): FormObjectModel | null;
+    /**
+     */
+    handleMissingErrors(receivedForm: FormModel): void;
+    /**
+     */
+    handleNewFormObject(receivedForm: FormModel): void;
+    /**
+     */
+    set mergePreviouslyEnteredObjects(mergePreviouslyEnteredObjects: boolean);
+    /**
+     * Indicate if a new form object model should be merged with a previousled entered form object model
+     * Set this property to false on the form that receives the new form to skip the merge behavior
+     */
+    get mergePreviouslyEnteredObjects(): boolean;
+    /**
+     */
+    handlePreviouslyEnteredFormObjects(receivedCurrentFormObject: FormObjectModel, previouslyEnteredFormObjects: Array<FormObjectModel>): void;
+    /**
+     */
+    mergeObjects(newObject: FormObjectModel, oldObject: FormObjectModel): FormObjectModel;
+    /**
+     */
+    findAttribute(findMethod: Function): AttributeType | null;
+}
+import ResourceModel from "../base/ResourceModel";
+import FormObjectModel from "./FormObjectModel";
+import ErrorCollection from "../error/ErrorCollection";
+import Href from "../href/Href";
+import Parameter from "../parameter/Parameter";
+import ErrorResponse from "../error/ErrorResponse";
+import AttributeSetModel from "../attributes/AttributeSetModel";
+import { ModularUIResponse } from "../../modularui";
+import { ModularUIModel } from "../types";
+import { AttributeType } from "../types";