@beinformed/ui 1.59.21 → 1.59.23

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

@@ -0,0 +1,209 @@
+/**
+ * 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>, errors: Array<ErrorResponse>): void;
+    /**
+     * get key
+     */
+    get key(): string;
+    /**
+     * Get content configuration for form objects
+     */
+    get contentConfiguration(): ContentConfiguration;
+    /**
+     */
+    get hasEndResultConfiguration(): boolean;
+    /**
+     * Indicates if object is dynamic.
+     *
+     * A subtle difference exists between objects for wizard style instrument dialogs and other objects.
+     * In the 'missing object' response, wizard style objects will include only the first attribute(s) to be answered,
+     * while other objects will include the complete set of attributes of that object.
+     *
+     * This difference is condensed in the term of 'dynamic objects': these objects start (in the 'missing object' response)
+     * with a very select set of attributes to be answered, and each successive 'missing elements' response will include next attributes to be answered.
+     * When an object is dynamic, the form contributions will mention a "dynamicObject": true property.
+     */
+    get isDynamic(): boolean;
+    /**
+     */
+    get hasDynamicValidations(): boolean;
+    /**
+     * Indicates if object is repeatable
+     */
+    get isRepeatable(): boolean;
+    /**
+     */
+    set repeatIndex(repeatIndex: number);
+    /**
+     */
+    get repeatIndex(): number;
+    /**
+     */
+    get maxRepeats(): number;
+    /**
+     */
+    get hasFixedNrOfRepeats(): boolean;
+    /**
+     */
+    get isRepeatWithUnknownTotal(): boolean;
+    /**
+     */
+    get isLastRepeat(): boolean;
+    /**
+     */
+    get repeatIndexLabel(): string | null;
+    /**
+     * 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(attributeCollection: 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(dynamicValidationsLoaded: boolean);
+    /**
+     */
+    get dynamicValidationsLoaded(): boolean;
+    /**
+     * Convert error json from a form service to validation messages on the form object and attributes
+     */
+    handleErrorValidations(errors: Array<{
+        anchor: {
+            objectid: string;
+            elementid?: string;
+        };
+        id: string;
+        message: string;
+        properties: MessageParameters;
+        layouthint: Array<string>;
+    }>): void;
+    /**
+     * Convert missing json from a form service to mandatory validation constraints and messages
+     */
+    handleMissingValidations(missing: {
+        anchors: Array<{
+            elements: Array<{
+                elementid: string;
+            }>;
+            objectid?: string;
+        } | {
+            anchor: {
+                elementid: string;
+                objectid?: string;
+            };
+        }>;
+    }): void;
+    /**
+     */
+    updateValidations(data: any): FormObjectModel;
+    /**
+     * Generate formdata object for current formobject based on formdata of attributes
+     */
+    get formdata(): {
+        [string]: any;
+    } | null;
+    /**
+     */
+    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 ErrorResponse from "../error/ErrorResponse";
+import { FormErrorAnchor } from "../types";
+import { MessageParameters } from "../../i18n";

package/esm/models/grouping/GroupingModel.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Group information model
+ * Put GroupModel here because of possible circular dependency with GroupingModel below
+ */
+export class GroupModel {
+    /**
+     */
+    constructor(group: Object, context: Object, contributions: Array<Object>, modelOptions?: ModelOptions);
+    _group: Object;
+    _context: Object;
+    _attributeCollection: AttributeCollection;
+    _grouping: GroupingModel | null;
+    /**
+     */
+    get type(): string;
+    /**
+     */
+    get id(): string;
+    /**
+     */
+    get label(): string;
+    /**
+     */
+    get attributeCollection(): AttributeCollection;
+    /**
+     */
+    get grouping(): GroupingModel | null;
+    /**
+     * Retrieve array of reference id's
+     */
+    get reference(): Array<number>;
+    /**
+     */
+    hasAttributeByKey(key: string): boolean;
+    /**
+     */
+    getAttributeByKey(key: string): AttributeType | null;
+}
+/**
+ * Grouping model to group lists
+ */
+export default class GroupingModel {
+    /**
+     */
+    constructor(data: Object, contexts: Array<Context>, modelOptions?: ModelOptions);
+    _prefix: string | null;
+    _groups: Array<GroupModel>;
+    /**
+     */
+    createGroup(data: Object, contributions: Array<Context>, modelOptions?: ModelOptions): Array<Object>;
+    /**
+     * add grouped prefix to the dynamicschema
+     */
+    getDynamicSchema(group: Object, dynamicschema: Object): Object;
+    /**
+     * Retrieve groups of grouping
+     */
+    get groups(): Array<GroupModel>;
+    /**
+     * Inidicates if Grouping has one or more groups
+     */
+    hasGroups(): boolean;
+    /**
+     * Get context of grouping
+     */
+    getContextFromContributionsByPrefix(contexts: Array<Object>, prefix: string | null): Object;
+    /**
+     */
+    hasAttributeByKey(key: string): boolean;
+    /**
+     */
+    getAttributeByKey(key: string): AttributeType | null;
+    /**
+     */
+    getGroupByAttributeKey(key: string): GroupModel | null;
+}
+import AttributeCollection from "../attributes/AttributeCollection";
+import { AttributeType } from "../types";
+import { ModelOptions } from "../types";
+type Context = {
+    prefix: string;
+    label: string;
+    metadata: Object;
+    attributes: Object[];
+};
+export {};

package/esm/models/href/Href.d.ts

@@ -0,0 +1,218 @@
+type HrefInput = any;
+export default Href;
+/**
+ * Defines a Href with the parameters
+ */
+declare class Href {
+    /**
+     * check if the path is referencing a camel route
+     */
+    static isCamelRoute(path: string): boolean;
+    /**
+     */
+    static checkAbsoluteUrl(href: string): boolean;
+    /**
+     * Retrieve the relative path part of a href string, e.g. https://www.beinformed.com/BeInformed/tab/view?q=url => /tab/view
+     */
+    static getPathFromString(href: string): string;
+    /**
+     * Retrieve hash of href string
+     */
+    static getHashFromString(href?: string): string;
+    /**
+     * Create a Href
+     */
+    constructor(href?: HrefInput, resourcetype?: string, modelOptions?: ModelOptions | null);
+    _path: string;
+    _hash: string;
+    _parameters: Array<Parameter>;
+    _resourcetype: string;
+    _method: $Keys<typeof HTTP_METHODS>;
+    _state: any;
+    _referenceHash: number | null;
+    _origin: string;
+    _contextPath: string;
+    /**
+     * Set resourctype
+     */
+    set resourcetype(resourcetype: string);
+    /**
+     * Retrieve resourceType
+     */
+    get resourcetype(): string;
+    /**
+     * Set the origin (e.g. http://example.com:18080)
+     */
+    set origin(origin: string);
+    /**
+     * Retrieve the origin (e.g. http://example.com:18080)<br>
+     * Empty when the default must be used
+     */
+    get origin(): string;
+    /**
+     * Set the context path if different from default
+     */
+    set contextPath(contextPath: string);
+    /**
+     * Get the context path
+     */
+    get contextPath(): string;
+    /**
+     * Set parameters from Href model input
+     */
+    setFromHref(href: Href): void;
+    /**
+     * Set the path of the Href, the part before the querystring question mark
+     */
+    set path(path: string);
+    /**
+     * Retrieve the path
+     */
+    get path(): string;
+    /**
+     * Replace parameters of Href
+     */
+    set parameters(parameters: Array<Parameter>);
+    /**
+     * Retrieve all paremters
+     */
+    get parameters(): Array<Parameter>;
+    /**
+     * Set hash
+     */
+    set hash(hash: string);
+    /**
+     * Retrieve hash
+     */
+    get hash(): string;
+    /**
+     */
+    set state(state: any);
+    /**
+     */
+    get state(): any;
+    /**
+     */
+    setFromLocationOrObject(href: LocationShape | HrefObject): void;
+    /**
+     */
+    setStateFromLocationOrObject(state?: any): void;
+    /**
+     * Set parameters from string input
+     */
+    setFromString(href: string): void;
+    /**
+     */
+    get isChangePassword(): boolean;
+    /**
+     */
+    get isExternal(): boolean;
+    /**
+     * Add a parameter for each parameter found in the querystring of an URL string, e.g. https://www.beinformed.com?q=url => q=url
+     */
+    addParametersFromString(href: string): Href;
+    /**
+     * Add a querystring parameter to the parameter collection of this Href, skips parameters that have a value of null
+     */
+    addParameter(name: string, value: string | null, prefix: string | null): Href;
+    /**
+     * Adds or overwrites a parameter when it exists and value is not null.
+     * Removes the parameter when the value is null
+     */
+    setParameter(name: string, value: string | null, prefix: string | null): Href;
+    /**
+     * Retrieve a parameter by it's name and (optionally) prefix
+     */
+    getParameter(name: string, prefix: string | null): Parameter | null;
+    /**
+     */
+    hasParameter(name: string, prefix: string | null): boolean;
+    /**
+     * Set request method
+     */
+    set method(method: $Keys<typeof HTTP_METHODS>);
+    /**
+     * Get request method
+     */
+    get method(): $Keys<typeof HTTP_METHODS>;
+    /**
+     * Remove a parameter from the parameter collection
+     */
+    removeParameter(name: string, prefix: string | null, value: string | null): Href;
+    /**
+     * Get the parameters as a querystring, e.g. param1=value1&param2=value2, optionally with prefix
+     */
+    getQuerystring(withPrefix?: boolean): string;
+    /**
+     * Retrieve a querystring that only contains parameter that can be send to the modular ui, parameters are filtered by prefix
+     */
+    getQuerystringForModularUI(prefix?: string): string;
+    /**
+     * Retrieve all parameters from the parameter collection in a querystring style name1=value1&name2=value2, without the prefix
+     */
+    get querystring(): string;
+    /**
+     */
+    setState(state: any): Href;
+    /**
+     * Retrieve the path combined with the base path (context-path) of the application, e.g. /BeInformed
+     */
+    get absolutepath(): string;
+    /**
+     * Retrieves the combination of the path and the querystring
+     */
+    get href(): string;
+    /**
+     * Getting the URL including the base path, querystring is prefixed
+     */
+    get absolutehref(): string;
+    /**
+     * Getting the URL including the base path, the querystring is prefixed
+     */
+    get absolutehrefPrefixedQuerystring(): string;
+    /**
+     * Checks if the URL starts within the given href
+     */
+    startsWith(href: Href | string): boolean;
+    /**
+     * Checks if the given Href equals this Href
+     */
+    equals(href: Href | string | null): boolean;
+    /**
+     */
+    equalsWithParameters(other: Href | string | null): boolean;
+    /**
+     * Indicates if the link is a content link
+     */
+    get isContent(): boolean;
+    /**
+     */
+    getReferenceHash(): number | null;
+    /**
+     */
+    setReferenceHash(referenceHash: number): void;
+    /**
+     * Returns a complete url from the Href
+     */
+    toString(): string;
+    /**
+     */
+    toLocation(): LocationShape;
+}
+import Parameter from "../parameter/Parameter";
+import { HTTP_METHODS } from "../../constants";
+type HrefObject = {
+    _path: string;
+    _hash: string;
+    _parameters: Parameter[];
+    _resourcetype: string;
+    _method: $Keys<{
+        POST: string;
+        GET: string;
+    }>;
+    _state: {
+        [key: string]: any;
+    } | null;
+    pathname: string | null;
+};
+import { ModelOptions } from "../types";

package/esm/models/href/ListHref.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Class representing the href of a list. It adds paging, sorting and filter parameters where necessary
+ *
+ * @augments Href
+ */
+export default class ListHref extends Href {
+    /**
+     * Create a ListHref
+     */
+    constructor(href?: HrefInput, list?: ListModel, isPrefixed?: boolean);
+    _isPrefixed: boolean;
+    _prefix: string | null;
+    _pagingName: string;
+    _pagesizeName: string;
+    _sortingName: string;
+    /**
+     * Retrieve parameter names from Href
+     */
+    setParameterNamesFromHref(href: ListHref): void;
+    /**
+     * Retrieve parameter names and settings from List model
+     */
+    setParameterNamesFromListModel(list: ListModel): void;
+    /**
+     * Setting the current page
+     */
+    set page(page: number | null);
+    /**
+     */
+    get page(): Parameter | null;
+    /**
+     * Setting the page size
+     */
+    set pagesize(pagesize: number | null);
+    /**
+     * Setting the sort value
+     */
+    set sort(sort: string | null);
+    /**
+     * Add filter parameters to the parameter collection
+     */
+    set filterCollection(filters: FilterCollection);
+    /**
+     * Getting prefix
+     */
+    get prefix(): string | null;
+    /**
+     * Getting paging name
+     */
+    get pagingName(): string;
+    /**
+     * Getting pagesize name
+     */
+    get pagesizeName(): string;
+    /**
+     * Getting sorting name
+     */
+    get sortingName(): string;
+}
+import Href from "./Href";
+import ListModel from "../list/ListModel";
+import Parameter from "../parameter/Parameter";
+import FilterCollection from "../filters/FilterCollection";
+import { HrefInput } from "./Href";

package/esm/models/layouthint/LayoutHintCollection.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Collection of layouthint
+ */
+export default class LayoutHintCollection extends BaseCollection<string> {
+    /**
+     * Constructs the layouthint collection
+     */
+    constructor(layouthint?: Array<string>);
+    /**
+     * Retrieve layout hints
+     */
+    get layouthint(): Array<string>;
+    /**
+     * Checks if a specific layouthint exists in the component configuration
+     * This method matches all exact matches and hints starting with. For example
+     * when calling layouth.has("hide"), this will return true for both "hide" and "hide-when-empty".<br>
+     * If only exact matches are required, use the method {@link LayoutHintCollection#hasExact}.
+     */
+    has(...hints: Array<string>): boolean;
+    /**
+     * Checks if a specific layouthint exists in the component configuration,
+     * only checks on exact matches.<br>
+     * If layouthints that start with the given hint should also match, use {@link LayoutHintCollection#has}.
+     * @param hints
+     * @returns {boolean}
+     */
+    hasExact(...hints: Array<string>): boolean;
+    /**
+     * Retrieve the first layouthint starting with hint
+     */
+    getByLayoutHint(hint: Function | string): null | string;
+    /**
+     * Get the value of a specific hint
+     * Format: hint=value
+     */
+    getLayoutHintValue(hint: string): string | null;
+    /**
+     * Get an array of multiple values from a specific hint
+     * Format: hint=value1;value2;value3
+     */
+    getLayoutHintValues(hint: string): Array<string> | null;
+}
+import BaseCollection from "../base/BaseCollection";

package/esm/models/links/LinkCollection.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Collection of links
+ *
+ * @see {LinkModel}
+ */
+export default class LinkCollection extends BaseCollection<LinkModel> {
+    /**
+     * Constructs the link collection
+     */
+    constructor(linkData?: Object, linkContributions?: Object, modelOptions?: ModelOptions);
+    /**
+     * Set Link collection
+     */
+    set links(links: Array<LinkModel>);
+    /**
+     * Getting links
+     */
+    get links(): Array<LinkModel>;
+    /**
+     * Get a link by it's key, handy for getting the self link
+     */
+    getLinkByKey(key: string): LinkModel | null;
+    /**
+     * Indicate if a link by key exists
+     */
+    hasLinkByKey(key: string): boolean;
+    /**
+     * Get a link by it's Href
+     */
+    getLinkByHref(href: Href | string): LinkModel | null;
+    /**
+     * Indicate if a link by href exists
+     */
+    hasLinkByHref(href: Href | string): boolean;
+    /**
+     * Getting the links by group key. For instance getting all 'tab' links of the web application.
+     */
+    getLinksByGroup(...args: Array<string>): LinkCollection;
+    /**
+     * Retrieve links by resource type
+     */
+    getLinkByResourceType(resourceType: string): LinkCollection;
+    /**
+     * Retrieve links including a layout hint
+     */
+    getLinksByLayoutHint(hint: string): LinkCollection;
+    /**
+     * Indicates if a link with layout hint exists
+     */
+    hasLinksByLayoutHint(hint: string): boolean;
+    /**
+     * Get all href of links in collection in an array of Href's
+     */
+    toHrefArray(): Array<Href>;
+    /**
+     * Check if link exists in collection
+     */
+    hasLink(link: LinkModel): boolean;
+    /**
+     * Updates the collection with a new link, when the link to update does not exist, it is added to the collection
+     */
+    update(newLink: LinkModel): LinkCollection;
+    /**
+     * Use as path regex for react router routes
+     */
+    get routePath(): string;
+}
+import LinkModel from "./LinkModel";
+import BaseCollection from "../base/BaseCollection";
+import Href from "../href/Href";
+import { ModelOptions } from "../types";