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

package/types/models/attributes/input-constraints/PasswordLowerAndUpperCaseConstraint.d.ts

@@ -0,0 +1,23 @@
+export default PasswordLowerAndUpperCaseConstraint;
+/**
+ */
+declare class PasswordLowerAndUpperCaseConstraint {
+    /**
+     */
+    get id(): string;
+    /**
+     */
+    hasValidation(): boolean;
+    /**
+     */
+    get defaultMessage(): string;
+    /**
+     */
+    get parameters(): {};
+    /**
+     */
+    validate(value: string): boolean;
+    /**
+     */
+    get isMandatoryConstraint(): boolean;
+}

package/types/models/attributes/input-constraints/PasswordMinNumericCharactersConstraint.d.ts

@@ -0,0 +1,32 @@
+export default PasswordMinNumericCharactersConstraint;
+/**
+ */
+declare class PasswordMinNumericCharactersConstraint {
+    /**
+     */
+    constructor(minNumeric: number);
+    _minNumeric: number;
+    /**
+     */
+    get id(): string;
+    /**
+     */
+    get minNumeric(): number;
+    /**
+     */
+    hasValidation(): boolean;
+    /**
+     */
+    get defaultMessage(): string;
+    /**
+     */
+    get parameters(): {
+        "min-numeric": number;
+    };
+    /**
+     */
+    validate(value: string): boolean;
+    /**
+     */
+    get isMandatoryConstraint(): boolean;
+}

package/types/models/attributes/input-constraints/PasswordMinSpecialCharactersConstraint.d.ts

@@ -0,0 +1,32 @@
+export default PasswordMinSpecialCharactersConstraint;
+/**
+ */
+declare class PasswordMinSpecialCharactersConstraint {
+    /**
+     */
+    constructor(minSpecial: number);
+    _minSpecial: number;
+    /**
+     */
+    get id(): string;
+    /**
+     */
+    get minSpecial(): number;
+    /**
+     */
+    hasValidation(): boolean;
+    /**
+     */
+    get defaultMessage(): string;
+    /**
+     */
+    get parameters(): {
+        "min-special": number;
+    };
+    /**
+     */
+    validate(value: string): boolean;
+    /**
+     */
+    get isMandatoryConstraint(): boolean;
+}

package/types/models/attributes/input-constraints/PasswordThreeConsecutiveCharactersNotAllowedConstraint.d.ts

@@ -0,0 +1,35 @@
+export default PasswordThreeConsecutiveCharactersNotAllowedConstraint;
+/**
+ */
+declare class PasswordThreeConsecutiveCharactersNotAllowedConstraint {
+    /**
+     */
+    constructor(maxSequence?: number);
+    _maxSequence: number;
+    /**
+     */
+    get id(): string;
+    /**
+     */
+    get maxSequence(): number;
+    /**
+     */
+    hasValidation(): boolean;
+    /**
+     */
+    get defaultMessage(): string;
+    /**
+     */
+    get parameters(): {
+        "max-sequence": number;
+    };
+    /**
+     */
+    hasNoSequenceOfIdenticalCharacters(value: string): boolean;
+    /**
+     */
+    validate(value: string): boolean;
+    /**
+     */
+    get isMandatoryConstraint(): boolean;
+}

package/types/models/attributes/input-constraints/RangeConstraint.d.ts

@@ -0,0 +1,97 @@
+export default RangeConstraint;
+/**
+ */
+declare class RangeConstraint {
+    /**
+     */
+    constructor(startAttribute: AttributeType, endAttribute: AttributeType);
+    _start: AttributeType;
+    _end: AttributeType;
+    /**
+     */
+    get id(): string;
+    /**
+     */
+    get defaultMessage(): string;
+    /**
+     */
+    hasValidation(): boolean;
+    /**
+     */
+    get parameters(): {};
+    /**
+     */
+    get start(): AttributeType;
+    /**
+     */
+    get end(): AttributeType;
+    /**
+     */
+    get rangeType(): string;
+    /**
+     */
+    get hasInclusiveBounds(): boolean;
+    /**
+     */
+    get util(): {
+        _isoFormat: string;
+        getLocale(): Locale;
+        getOptions(): {
+            weekStartsOn: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+            firstWeekContainsDate: 2 | 1 | 3 | 4 | 5 | 6 | 7;
+        };
+        toDate(date: string, inputFormat?: string): Date; /**
+         */
+        toFormat(date: string | Date, targetFormat: string): string;
+        toISO(date: string | Date, sourceFormat?: string): string;
+        now(): string;
+        convertFormat(sourceFormat: string): string;
+        hasFormat(date: string, sourceFormat: string): boolean;
+        isValid(date: string, inputFormat?: string): boolean;
+        isAfter(inputDate: string, afterISODate: string, inputFormat?: string): boolean;
+        isSameOrAfter(inputDate: string, afterISODate: string, inputFormat?: string): boolean;
+        isBefore(inputDate: string, beforeISODate: string, inputFormat?: string): boolean;
+        isSameOrBefore(inputDate: string, beforeISODate: string, inputFormat?: string): boolean;
+        isSame(inputDate: string, compareDate: string, inputFormat?: string): boolean;
+        isSameDay(inputDate: string, compareDate: string, inputFormat?: string): boolean;
+        isOther(inputDate: string, compareDate: string, inputFormat?: string): boolean;
+        isWeekend(inputDate: string): boolean;
+        addSeconds(date: string, amount: number): string;
+        addMinutes(date: string, amount: number): string;
+        addHours(date: string, amount: number): string;
+        addDays(date: string, amount: number): string;
+        addWeeks(date: string, amount: number): string;
+        addMonths(date: string, amount: number): string;
+        addYears(date: string, amount: number): string;
+        subtractSeconds(date: string, amount: number): string;
+        subtractMinutes(date: string, amount: number): string;
+        subtractHours(date: string, amount: number): string;
+        subtractDays(date: string, amount: number): string;
+        subtractWeeks(date: string, amount: number): string;
+        subtractMonths(date: string, amount: number): string;
+        subtractYears(date: string, amount: number): string;
+        startOfMonth(date: string, inputFormat?: string): string;
+        endOfMonth(date: string, inputFormat?: string): string;
+        startOfWeek(date: string, inputFormat?: string): string;
+        getHours(date: string | Date): number;
+        getMinutes(date: string | Date): number;
+        getWeek(date: string): number;
+        setYear(date: string, year: number): string;
+        setMonth(date: string, month: number): string;
+        setHour(date: string, hour: number): string;
+        setMinute(date: string, minute: number): string;
+        setSecond(date: string, second: number): string;
+        setMilliseconds(date: string, milliseconds: number): string;
+        setTime(date: string, hours: number, minutes: number, seconds: number, milliseconds: number): string;
+    };
+    /**
+     */
+    doValidate(startValue: string, endValue: string): boolean;
+    /**
+     */
+    validate(): boolean;
+    /**
+     */
+    get isMandatoryConstraint(): boolean;
+}
+import { AttributeType } from "../../types";

package/types/models/attributes/input-constraints/RegexConstraint.d.ts

@@ -0,0 +1,37 @@
+type RegexObject = {
+    messageKey: string;
+    defaultMessage: string;
+    regex: string | RegExp;
+};
+export default RegexConstraint;
+/**
+ */
+declare class RegexConstraint {
+    /**
+     */
+    constructor(regexConstraint: RegexObject);
+    _regexConstraint: Object;
+    /**
+     */
+    get id(): any;
+    /**
+     */
+    get regexConstraint(): any;
+    /**
+     */
+    hasValidation(): boolean;
+    /**
+     */
+    get defaultMessage(): any;
+    /**
+     */
+    get parameters(): {
+        regex: any;
+    };
+    /**
+     */
+    validate(value: string): boolean;
+    /**
+     */
+    get isMandatoryConstraint(): boolean;
+}

package/types/models/attributes/input-constraints/StringLengthConstraint.d.ts

@@ -0,0 +1,46 @@
+export default StringLengthConstraint;
+/**
+ */
+declare class StringLengthConstraint {
+    /**
+     */
+    constructor(minLength: number | null, maxLength: number | null);
+    _minLength: number | null;
+    _maxLength: number | null;
+    /**
+     */
+    get id(): string;
+    /**
+     */
+    get minLength(): number;
+    /**
+     */
+    get maxLength(): number;
+    /**
+     */
+    hasValidation(): boolean;
+    /**
+     */
+    isExactLength(value: string): boolean;
+    /**
+     */
+    isBetween(value: string): boolean;
+    /**
+     */
+    isLongEnough(value: string): boolean;
+    /**
+     */
+    isSmallEnough(value: string): boolean;
+    /**
+     */
+    get defaultMessage(): string;
+    /**
+     */
+    get parameters(): {};
+    /**
+     */
+    validate(value: string): boolean;
+    /**
+     */
+    get isMandatoryConstraint(): boolean;
+}

package/types/models/attributes/input-constraints/XMLConstraint.d.ts

@@ -0,0 +1,26 @@
+export default XMLConstraint;
+/**
+ */
+declare class XMLConstraint {
+    /**
+     */
+    get id(): string;
+    /**
+     */
+    hasValidation(): boolean;
+    /**
+     */
+    get defaultMessage(): string;
+    /**
+     */
+    get parameters(): {};
+    /**
+     */
+    isValidXML(value: string): boolean;
+    /**
+     */
+    validate(value: string): boolean;
+    /**
+     */
+    get isMandatoryConstraint(): boolean;
+}

package/types/models/attributes/layouthint-rules/BaseLayoutHintRule.d.ts

@@ -0,0 +1,46 @@
+export default BaseLayoutHintRule;
+/**
+ * Abstract class for layout hint rules
+ * @abstract
+ */
+declare class BaseLayoutHintRule {
+    /**
+     * Indicates if the rule implements the isApplicableForHint method
+     * @type {boolean}
+     * @default false
+     */
+    static checkHintApplicability: boolean;
+    /**
+     * Indicates if the rule instance is applicable for a specific attribute<br>
+     * @default true
+     */
+    static isApplicableForAttribute(attribute: AttributeType): boolean;
+    /**
+     * Indicates if the rule instance is applicable for a specific hint<br>
+     * Is required when checkHintApplicability is true
+     * @abstract
+     */
+    static isApplicableForHint(hint: string): boolean;
+    /**
+     * Initialize the rule when isApplicableForAttribute is true and checkHintApplicability is false
+     * @abstract
+     */
+    static initAttribute(attribute: AttributeType): ILayoutHintRule;
+    /**
+     * Initialize the rule when isApplicableForAttribute and isApplicableForHint are both true,
+     * it receives the hint. Allows a rule to be instantiated multiple times for an attribute,
+     * but once for each hint entry
+     * @abstract
+     */
+    static initHint(hint: string): ILayoutHintRule;
+    /**
+     * Abstract method, implements process of layout hint rule,
+     * use this to enhance the applicable attribute or the attribute collection
+     * @abstract
+     */
+    process(attribute: AttributeModel, attributes: AttributeCollection): void;
+}
+import AttributeModel from "../AttributeModel";
+import AttributeCollection from "../AttributeCollection";
+import { AttributeType } from "../../types";
+import { ILayoutHintRule } from "../../types";

package/types/models/attributes/layouthint-rules/DependentAttribute.d.ts

@@ -0,0 +1,57 @@
+export default DependentAttribute;
+/**
+ * Depending attributes hint logic
+ */
+declare class DependentAttribute extends BaseLayoutHintRule {
+    /**
+     * Used on initHint to create an instance of this rule
+     */
+    static getRuleInstance(): DependentAttribute;
+    /**
+     */
+    static initHint(hint: string): any;
+    _action: string;
+    _control: string;
+    _operator: string;
+    _options: Array<string>;
+    /**
+     */
+    set action(arg: string);
+    /**
+     */
+    get action(): string;
+    /**
+     */
+    set control(arg: string);
+    /**
+     */
+    get control(): string;
+    /**
+     */
+    set operator(arg: string);
+    /**
+     */
+    get operator(): string;
+    /**
+     */
+    set options(arg: string[]);
+    /**
+     */
+    get options(): string[];
+    /**
+     */
+    processEqualsOptions(controlAttribute: ChoiceAttributeModel | BooleanAttributeModel): boolean;
+    /**
+     */
+    processIncludesOptions(controlAttribute: ChoiceAttributeModel | BooleanAttributeModel): boolean;
+    /**
+     */
+    handleOperator(controlAttribute: ChoiceAttributeModel | BooleanAttributeModel): boolean;
+    /**
+     */
+    getControlAttribute(attributes: AttributeCollection): ChoiceAttributeModel | BooleanAttributeModel | null;
+}
+import BaseLayoutHintRule from "./BaseLayoutHintRule";
+import ChoiceAttributeModel from "../ChoiceAttributeModel";
+import BooleanAttributeModel from "../BooleanAttributeModel";
+import AttributeCollection from "../AttributeCollection";

package/types/models/attributes/layouthint-rules/LayoutHintRuleCollection.d.ts

@@ -0,0 +1,27 @@
+export function addLayoutHintRule(rule: Class<BaseLayoutHintRule>): void;
+export function updateLayoutHintRules(updater: LayoutHintRulesUpdater): void;
+export default LayoutHintRuleCollection;
+import BaseLayoutHintRule from "./BaseLayoutHintRule";
+type LayoutHintRulesUpdater = (rules: Class<BaseLayoutHintRule>[]) => Class<BaseLayoutHintRule>[];
+/**
+ * Collection of layout hint rules
+ */
+declare class LayoutHintRuleCollection extends BaseCollection<ILayoutHintRule> {
+    /**
+     * Set layout hint rules on the applicable attributes
+     */
+    static setLayoutHintRules<T, AttributeType_1>(attribute: T): T;
+    constructor(initCollection?: ILayoutHintRule[]);
+    /**
+     * Retrieve all rules available in the collection
+     */
+    get allRules(): Class<BaseLayoutHintRule>[];
+    /**
+     * Process layout hint rules in the collection
+     */
+    process(attribute: AttributeModel, attributes: AttributeCollection): void;
+}
+import { ILayoutHintRule } from "../../types";
+import BaseCollection from "../../base/BaseCollection";
+import AttributeModel from "../AttributeModel";
+import AttributeCollection from "../AttributeCollection";

package/types/models/attributes/layouthint-rules/RemainingTotalUploadSize.d.ts

@@ -0,0 +1,17 @@
+export default RemainingTotalUploadSize;
+/**
+ * This pattern enables showing the upload file size remaining when uploading resources<br>
+ * The rule depends on other attributes with the INITIAL_TOTAL_FILESIZE and MAX_TOTAL_FILESIZE layout hints
+ */
+declare class RemainingTotalUploadSize extends BaseLayoutHintRule {
+    /**
+     */
+    static initAttribute(): ILayoutHintRule;
+    /**
+     */
+    processUploadInformation(attribute: UploadAttributeModel, attributes: AttributeCollection): void;
+}
+import BaseLayoutHintRule from "./BaseLayoutHintRule";
+import UploadAttributeModel from "../UploadAttributeModel";
+import AttributeCollection from "../AttributeCollection";
+import { ILayoutHintRule } from "../../types";

package/types/models/base/BaseCollection.d.ts

@@ -0,0 +1,89 @@
+export default BaseCollection;
+/**
+ * Base class for collections of models
+ */
+declare class BaseCollection<T> {
+    /**
+     * Construct base collection
+     */
+    constructor(initCollection?: Array<T>);
+    _collection: Array<T>;
+    /**
+     * Replace current collection with a new collection
+     */
+    set collection(arg: T[]);
+    /**
+     * Retrieve current collection
+     */
+    get collection(): T[];
+    /**
+     * Add an other collection, array of items or single item to this collection;
+     */
+    add(items: BaseCollection<T> | Array<T> | T): BaseCollection<T>;
+    /**
+     * Remove an item from the collection by it's index.
+     */
+    removeByIndex(itemIndex: number): void;
+    /**
+     * Indicates if the collection has items
+     */
+    get hasItems(): boolean;
+    /**
+     * Indicates if collection is empty
+     */
+    get isEmpty(): boolean;
+    /**
+     * Retrieve all items in collection
+     */
+    get all(): T[];
+    /**
+     * Get the size of this collection
+     */
+    get size(): number;
+    /**
+     * Get the size of this collection
+     */
+    get length(): number;
+    /**
+     * Return first link in collection
+     */
+    get first(): T;
+    /**
+     */
+    get last(): T;
+    /**
+     */
+    get(index: number): T | null;
+    /**
+     * Find item
+     */
+    find(callbackfn: (value: T, index: number, array: Array<T>) => any, thisArg?: any): T | null;
+    /**
+     * Filter items
+     */
+    filter(callbackfn: (value: T, index: number, array: Array<T>) => any, thisArg?: any): Array<T>;
+    /**
+     * Check if at least one item occurs
+     */
+    some(callbackfn: (value: T, index: number, array: Array<T>) => any, thisArg?: any): boolean;
+    /**
+     */
+    every(callbackfn: (value: T, index: number, array: Array<T>) => any, thisArg?: any): boolean;
+    /**
+     */
+    map<U>(callbackfn: (value: T, index: number, array: Array<T>) => U, thisArg?: T): U[];
+    /**
+     */
+    forEach(callbackfn: (value: T, index: number, array: Array<T>) => any, thisArg?: any): void;
+    /**
+     */
+    sort(compareFn?: (a: T, b: T) => number): Array<T>;
+    /**
+     * Retrieve an alphabetically sorted array of items
+     */
+    get sorted(): T[];
+    /**
+     * Returns a clone of the model (this is not a deep copy)
+     */
+    clone(deepcopy?: boolean): this;
+}

package/types/models/base/BaseModel.d.ts

@@ -0,0 +1,58 @@
+type BaseDehydrateData = {};
+export default BaseModel;
+/**
+ * Base model
+ */
+declare class BaseModel {
+    /**
+     * constructor
+     */
+    constructor(data: Object, contributions: Object);
+    _data: Object;
+    _contributions: Object;
+    _layouthint: LayoutHintCollection;
+    _connectKey: string;
+    /**
+     * Retrieve data
+     */
+    get data(): Object;
+    /**
+     */
+    getData(propName: string, defaultValue?: any): any;
+    /**
+     * Retrieve contributions
+     */
+    get contributions(): Object;
+    /**
+     */
+    getContribution(propName: string, defaultValue?: any): any;
+    /**
+     * Set the layouthint
+     */
+    set layouthint(arg: LayoutHintCollection);
+    /**
+     * Getting the layouthint
+     */
+    get layouthint(): LayoutHintCollection;
+    /**
+     * Indicates if the model has data
+     */
+    get hasData(): boolean;
+    /**
+     */
+    set connectKey(arg: string);
+    /**
+     */
+    get connectKey(): string;
+    /**
+     */
+    dehydrate(): BaseDehydrateData;
+    /**
+     */
+    rehydrate(data: Object): void;
+    /**
+     * Returns a clone of the model (this is not a deep copy)
+     */
+    clone(deepcopy?: boolean): any;
+}
+import LayoutHintCollection from "../layouthint/LayoutHintCollection";

package/types/models/base/ResourceCollection.d.ts

@@ -0,0 +1,19 @@
+export default ResourceCollection;
+/**
+ * The ResourceCollection makes it possible to add child models to a collection of models
+ * These child models are fetched using the ModularUI util
+ */
+declare class ResourceCollection<T, IModelWithChildModels> extends BaseCollection<T> {
+    constructor(initCollection?: T[]);
+    /**
+     * Retrieve all child model links and flatten it into an array with single entries, removing all undefined items
+     */
+    getInitialChildModelLinks(): Array<LinkModel>;
+    /**
+     * Pass through models for setchildmodels to items of this collection
+     */
+    setChildModels(models: Array<ModularUIModel>): void;
+}
+import BaseCollection from "./BaseCollection";
+import LinkModel from "../links/LinkModel";
+import { ModularUIModel } from "../types";