@beinformed/ui 1.24.1-beta.1 → 1.24.1-beta.4

package/types/models/filters/AssignmentFilterModel.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Assignment filter consists of two filters: assignment type and user filter
+ */
+export default class AssignmentFilterModel extends BaseFilterModel {
+    _assignmenttype: AttributeType | null;
+    _user: AttributeType | null;
+    /**
+     */
+    get key(): string;
+    /**
+     */
+    get contextid(): string;
+    /**
+     * Creates an assignmenttype model when assignmenttype json is present
+     */
+    createAssignmentTypeModel(): AttributeType | null;
+    /**
+     * Creates an assignmenttype model when userkey json is present
+     */
+    createUserModel(): AttributeType | null;
+    /**
+     * The assignment filter consists of two part. This method return the assignment type attribute
+     */
+    get assignmenttype(): AttributeType;
+    /**
+     * The assignment filter consists of two part. This method return the user identifier attribute
+     */
+    get user(): AttributeType;
+    /**
+     * Reset the values within the filter
+     */
+    reset(): AssignmentFilterModel;
+}
+import BaseFilterModel from "../filters/BaseFilterModel";
+import { AttributeType } from "../types";

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

@@ -0,0 +1,85 @@
+/**
+ * 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(arg: 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;
+    /**
+     * Set context of filter
+     */
+    set context(arg: 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(): {
+        name: string;
+        value: string | null;
+    }[];
+    /**
+     * 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;
+}
+import BaseModel from "../base/BaseModel";
+import { AttributeType } from "../types";
+import { FilterType } from "../types";

package/types/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/types/models/filters/FilterCollection.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Contains a collection of filters
+ */
+export default class FilterCollection extends BaseCollection<FilterType> {
+    /**
+     * Construct a collection of filters
+     */
+    constructor(data?: Object, contributions?: Object);
+    collection: any;
+    /**
+     */
+    createFilter(filterKey: string, data: Object, contributions: Object): 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 RangeFilterModel from "../filters/RangeFilterModel";
+import AssignmentFilterModel from "../filters/AssignmentFilterModel";
+import { AttributeType } from "../types";

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

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

package/types/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/types/models/form/FormModel.d.ts

@@ -0,0 +1,309 @@
+export default FormModel;
+/**
+ */
+declare class FormModel extends ResourceModel {
+    _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;
+    _parameters: Array<Parameter>;
+    _tokens: Array<string>;
+    /**
+     */
+    set lastUpdate(arg: number);
+    /**
+     */
+    get lastUpdate(): number;
+    /**
+     */
+    set currentFormObject(arg: FormObjectModel);
+    /**
+     */
+    get currentFormObject(): FormObjectModel;
+    /**
+     */
+    set endResultFormObjects(arg: FormObjectModel[]);
+    /**
+     */
+    get endResultFormObjects(): FormObjectModel[];
+    /**
+     */
+    set parameters(arg: Parameter[]);
+    /**
+     */
+    get parameters(): Parameter[];
+    /**
+     */
+    set isComplete(arg: 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(): FormObjectModel[];
+    /**
+     */
+    get objectKeys(): 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(arg: FormObjectModel[]);
+    /**
+     * Completed objects are previously entered questions
+     */
+    get completedFormObjects(): 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(arg: 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(): FormObjectModel[];
+    /**
+     * Handle end results
+     */
+    setEndResultFormObjects(): Array<FormObjectModel>;
+    /**
+     */
+    get expectsEndResultFormObjects(): boolean;
+    /**
+     */
+    getEndResultFormObjects(): Array<FormObjectModel>;
+    /**
+     */
+    set previousEndResultKeys(arg: string[]);
+    /**
+     */
+    get previousEndResultKeys(): 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(arg: ErrorCollection);
+    /**
+     */
+    get errorCollection(): ErrorCollection;
+    /**
+     */
+    set commit(arg: boolean);
+    /**
+     * Indicates if the form needs to be committed
+     */
+    get commit(): boolean;
+    /**
+     */
+    set isFinished(arg: boolean);
+    /**
+     * Inidicates if form is finished: Form is completely entered and committed
+     */
+    get isFinished(): boolean;
+    /**
+     * Handle success redirects
+     */
+    get successRedirect(): Href;
+    /**
+     */
+    get redirectLocation(): Href;
+    /**
+     */
+    getSuccessData(): Object;
+    /**
+     * Href handling
+     */
+    setParameters(modularuiResponse: ModularUIResponse): Array<Parameter>;
+    /**
+     */
+    selfhrefNoCommitParam(): Href;
+    /**
+     */
+    selfhrefWithCommitParam(): Href;
+    /**
+     * Replaces all tokens with the given collection of tokens
+     */
+    set tokens(arg: string[]);
+    /**
+     * Handle form tokens to indicate concurrent form use
+     */
+    get tokens(): 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;
+    /**
+     * Form navigation: has next step or is last
+     */
+    get hasNextStep(): boolean;
+    /**
+     * Merge existing form with new form
+     */
+    update(receivedForm: ModularUIModel): FormModel;
+    lastServerUpdate: any;
+    /**
+     */
+    updateValidations(data: any): FormModel;
+    /**
+     * Process finished form
+     */
+    handleFinished(receivedForm: FormModel): void;
+    _data: any;
+    /**
+     */
+    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(arg: 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 { ModularUIResponse } from "../../modularui";
+import { ModularUIModel } from "../types";
+import { AttributeType } from "../types";

package/types/models/form/FormObjectModel.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Form Object
+ */
+export default class FormObjectModel extends BaseModel {
+    /**
+     */
+    static createEmpty(formObjectModel: FormObjectModel): FormObjectModel;
+    _attributeCollection: AttributeCollection;
+    _contentConfiguration: ContentConfiguration;
+    _errorCollection: ErrorCollection;
+    _repeatIndex: number;
+    _dynamicValidationsLoaded: boolean;
+    /**
+     */
+    equals(object: FormObjectModel | null, withRepeatIndex?: boolean): boolean;
+    /**
+     */
+    getAttributeByAttribute(attribute: AttributeType): AttributeType | null;
+    /**
+     */
+    getAttributeByKey(key: string): AttributeType | null;
+    /**
+     */
+    hasAttributeByKey(key: string): boolean;
+    /**
+     * Get elements from both the missing attributes and the result attributes
+     */
+    getElements(): Array<Object>;
+    /**
+     * Map available contributions on the available data. Only use contributions that are needed for the data
+     */
+    getApplicableAttributeContributions(): Array<Object>;
+    /**
+     * Recursevily check if an attribute id occurs in the tree of attribute contributions.
+     * The complete leaf of the tree is returned when an attribute id matches
+     */
+    getAttributesInData(dataElementIds: Array<string>, attributesContributions: Object): Array<Object>;
+    /**
+     */
+    getInitialChildModelLinks(): Array<LinkModel>;
+    /**
+     */
+    setChildModels(models: Array<ModularUIModel>): void;
+    /**
+     * get key
+     */
+    get key(): string;
+    /**
+     * Get content configuration for form objects
+     */
+    get contentConfiguration(): ContentConfiguration;
+    /**
+     */
+    get hasEndResultConfiguration(): boolean;
+    /**
+     * Indicates if object is dynamic. A dynamic object should be submitted on each attribute change
+     */
+    get isDynamic(): boolean;
+    /**
+     */
+    get hasDynamicValidations(): boolean;
+    /**
+     * Indicates if object is repeatable
+     */
+    get isRepeatable(): boolean;
+    /**
+     */
+    set repeatIndex(arg: number);
+    /**
+     */
+    get repeatIndex(): number;
+    /**
+     */
+    get maxRepeats(): number;
+    /**
+     */
+    get hasFixedNrOfRepeats(): boolean;
+    /**
+     */
+    get isRepeatWithUnknownTotal(): boolean;
+    /**
+     */
+    get isLastRepeat(): boolean;
+    /**
+     */
+    get repeatIndexLabel(): string;
+    /**
+     * Get label of form object
+     */
+    get label(): string;
+    /**
+     * Get introText of form object
+     */
+    get introText(): string;
+    /**
+     * Get assistent of form object
+     */
+    get assistent(): string;
+    /**
+     * Get button labels
+     */
+    get buttonLabels(): Object;
+    /**
+     */
+    set attributeCollection(arg: AttributeCollection);
+    /**
+     * get attribute collection
+     */
+    get attributeCollection(): AttributeCollection;
+    /**
+     */
+    mergeObject(oldObject: FormObjectModel): void;
+    /**
+     * Update attribute
+     */
+    updateAttribute(attribute: AttributeType, value: any): AttributeType;
+    /**
+     * Inidicates if Form is changed since a given timestamp (Date.now)
+     */
+    isChangedSince(timestamp: number): boolean;
+    /**
+     * Reset all errors on Form Object
+     */
+    resetErrors(): void;
+    /**
+     * Get error messages
+     */
+    get errorCollection(): ErrorCollection;
+    /**
+     * Registers an error that was received from a server response
+     */
+    addServerError(error: FormErrorAnchor): void;
+    /**
+     */
+    hasServerErrors(): boolean;
+    /**
+     */
+    hasErrors(): boolean;
+    /**
+     */
+    get isValid(): boolean;
+    /**
+     */
+    set dynamicValidationsLoaded(arg: boolean);
+    /**
+     */
+    get dynamicValidationsLoaded(): boolean;
+    /**
+     */
+    updateValidations(data: any): FormObjectModel;
+    /**
+     * Generate formdata object for current formobject based on formdata of attributes
+     */
+    get formdata(): {};
+    /**
+     */
+    getFormData(validationData?: boolean): {
+        [string]: any;
+    } | null;
+}
+import BaseModel from "../base/BaseModel";
+import AttributeCollection from "../attributes/AttributeCollection";
+import ContentConfiguration from "../contentconfiguration/ContentConfiguration";
+import ErrorCollection from "../error/ErrorCollection";
+import { AttributeType } from "../types";
+import LinkModel from "../links/LinkModel";
+import { ModularUIModel } from "../types";
+import { FormErrorAnchor } from "../types";