@vixoniccom/modules 2.11.0 → 2.12.0-dev.2

package/dist/lib/containers/group.js

@@ -1,47 +1,56 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || Object.assign || function(t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-        s = arguments[i];
-        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-            t[p] = s[p];
-    }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var base_1 = require("../base");
-var inputs_1 = require("../inputs");
-var utils_1 = require("../utils");
-var typeDefs_1 = require("../utils/typeDefs");
-var Group = (function (_super) {
-    __extends(Group, _super);
-    function Group(options) {
-        var _this = _super.call(this, options) || this;
-        _this.type = Group.type;
-        _this.valueTypeDef = function () {
-            return typeDefs_1.getDefsFromInputs(_this.items.filter(inputs_1.isInput));
-        };
-        _this.items = options.items;
-        return _this;
-    }
-    Group.fromJSON = function (value) {
-        return new Group(__assign({}, value, { items: value.items.map(function (i) {
-                return utils_1.createComponentFromJSON(i.type, i);
-            }) }));
-    };
-    Group.isInstance = function (instance) {
-        return instance.type === Group.type;
-    };
-    Group.type = 'group';
-    return Group;
-}(base_1.BaseElement));
-exports.Group = Group;
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Group = void 0;
+var base_1 = require("../base");
+var inputs_1 = require("../inputs");
+var typeDefs_1 = require("../utils/typeDefs");
+var Group = /** @class */ (function (_super) {
+    __extends(Group, _super);
+    function Group(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = Group.type;
+        _this.valueTypeDef = function () {
+            return typeDefs_1.getDefsFromInputs(_this.items.filter(inputs_1.isInput));
+        };
+        _this.items = options.items;
+        return _this;
+    }
+    Group.fromJSON = function (value) {
+        var createComponentFromJSON = require('../utils').default;
+        return new Group(__assign(__assign({}, value), { items: value.items.map(function (i) {
+                return createComponentFromJSON(i.type, i);
+            }) }));
+    };
+    Group.isInstance = function (instance) {
+        return instance.type === Group.type;
+    };
+    Group.type = 'group';
+    return Group;
+}(base_1.BaseElement));
+exports.Group = Group;

package/dist/lib/containers/index.d.ts

@@ -1,6 +1,6 @@
-import { Group } from './group';
-import { List } from './list';
-import { DynamicMatrix } from './dynamic-matrix';
-export { Group, List, DynamicMatrix };
-export declare type ContainerComponent = Group | List;
-export declare const allContainer: (typeof Group | typeof List | typeof DynamicMatrix)[];
+import { Group } from './group';
+import { List } from './list';
+import { DynamicMatrix } from './dynamic-matrix';
+export { Group, List, DynamicMatrix };
+export declare type ContainerComponent = Group | List;
+export declare const allContainer: (typeof Group | typeof List | typeof DynamicMatrix)[];

package/dist/lib/containers/index.js

@@ -1,13 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var group_1 = require("./group");
-exports.Group = group_1.Group;
-var list_1 = require("./list");
-exports.List = list_1.List;
-var dynamic_matrix_1 = require("./dynamic-matrix");
-exports.DynamicMatrix = dynamic_matrix_1.DynamicMatrix;
-exports.allContainer = [
-    group_1.Group,
-    list_1.List,
-    dynamic_matrix_1.DynamicMatrix
-];
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allContainer = exports.DynamicMatrix = exports.List = exports.Group = void 0;
+var group_1 = require("./group");
+Object.defineProperty(exports, "Group", { enumerable: true, get: function () { return group_1.Group; } });
+var list_1 = require("./list");
+Object.defineProperty(exports, "List", { enumerable: true, get: function () { return list_1.List; } });
+var dynamic_matrix_1 = require("./dynamic-matrix");
+Object.defineProperty(exports, "DynamicMatrix", { enumerable: true, get: function () { return dynamic_matrix_1.DynamicMatrix; } });
+exports.allContainer = [
+    group_1.Group,
+    list_1.List,
+    dynamic_matrix_1.DynamicMatrix
+];

package/dist/lib/containers/list.d.ts

@@ -1,66 +1,66 @@
-import { Omit, BaseElement, IBaseElement } from '../base';
-import { RangeValue } from '../values';
-import { InputComponent } from '../inputs';
-import { UIComponent } from '../ui';
-import { TypeDefMap } from '../utils/typeDefs';
-import { ErrorsMap, Errors } from '../errors';
-import { Configuration } from '..';
-export declare type DisplayClass = '2-lines' | '1-line';
-export declare type DisplayAttributes = {
-    title: string;
-    subtitle?: string;
-};
-export interface IList extends IBaseElement {
-    id: string;
-    label: string;
-    itemSchema: (InputComponent | UIComponent)[];
-    itemDisplayClass: DisplayClass;
-    itemDisplayAttributes: DisplayAttributes;
-    description?: string;
-    range?: RangeValue;
-    sortable?: boolean;
-    showItemId?: boolean;
-}
-export interface ListJSON extends Omit<IList, 'itemSchema' | 'range'> {
-    range?: string;
-    itemSchema: {
-        type: string;
-    }[];
-}
-export declare type ListItem = {
-    [key: string]: any;
-    __id: string | undefined;
-};
-export declare namespace List {
-    type Value = ListItem[];
-    type ItemValue = ListItem;
-    type Error = {
-        type: 'ItemHasNoUniqueId';
-    } | {
-        type: 'InvalidListValue';
-    } | {
-        type: 'Min';
-        payload: number;
-    } | {
-        type: 'Max';
-        payload: number;
-    };
-}
-export declare class List extends BaseElement {
-    static readonly type: string;
-    type: string;
-    readonly itemSchema: (InputComponent | UIComponent)[];
-    readonly itemDisplayClass: DisplayClass;
-    readonly itemDisplayAttributes: DisplayAttributes;
-    readonly description?: string;
-    readonly range?: RangeValue;
-    readonly sortable?: boolean;
-    readonly showItemId?: boolean;
-    constructor(options: IList);
-    validate(value: List.Value | undefined, ctx: Configuration.Value): ErrorsMap | List.Error[];
-    validateItem(value: List.ItemValue, ctx: Configuration.Value): Errors<List.Error>;
-    isValidValue(v: any): v is List.Value;
-    valueTypeDef: () => TypeDefMap;
-    static fromJSON(value: ListJSON): List;
-    static isInstance(instance: any): instance is List;
-}
+import { BaseElement, IBaseElement } from '../base';
+import { RangeValue } from '../values';
+import { InputComponent } from '../inputs';
+import { UIComponent } from '../ui';
+import { TypeDefMap } from '../utils/typeDefs';
+import { ErrorsMap, Errors } from '../errors';
+import { Configuration } from '..';
+export declare type DisplayClass = '2-lines' | '1-line';
+export declare type DisplayAttributes = {
+    title: string;
+    subtitle?: string;
+};
+export interface IList extends IBaseElement {
+    id: string;
+    label: string;
+    itemSchema: (InputComponent | UIComponent)[];
+    itemDisplayClass: DisplayClass;
+    itemDisplayAttributes: DisplayAttributes;
+    description?: string;
+    range?: RangeValue;
+    sortable?: boolean;
+    showItemId?: boolean;
+}
+export interface ListJSON extends Omit<IList, 'itemSchema' | 'range'> {
+    range?: string;
+    itemSchema: {
+        type: string;
+    }[];
+}
+export declare type ListItem = {
+    [key: string]: any;
+    __id: string | undefined;
+};
+export declare namespace List {
+    type Value = ListItem[];
+    type ItemValue = ListItem;
+    type Error = {
+        type: 'ItemHasNoUniqueId';
+    } | {
+        type: 'InvalidListValue';
+    } | {
+        type: 'Min';
+        payload: number;
+    } | {
+        type: 'Max';
+        payload: number;
+    };
+}
+export declare class List extends BaseElement {
+    static readonly type = "list";
+    type: string;
+    readonly itemSchema: (InputComponent | UIComponent)[];
+    readonly itemDisplayClass: DisplayClass;
+    readonly itemDisplayAttributes: DisplayAttributes;
+    readonly description?: string;
+    readonly range?: RangeValue;
+    readonly sortable?: boolean;
+    readonly showItemId?: boolean;
+    constructor(options: IList);
+    validate(value: List.Value | undefined, ctx: Configuration.Value): ErrorsMap | List.Error[];
+    validateItem(value: List.ItemValue, ctx: Configuration.Value): Errors<List.Error>;
+    isValidValue(v: any): v is List.Value;
+    valueTypeDef: () => TypeDefMap;
+    static fromJSON(value: ListJSON): List;
+    static isInstance(instance: any): instance is List;
+}

package/dist/lib/containers/list.js

@@ -1,105 +1,114 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || Object.assign || function(t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-        s = arguments[i];
-        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-            t[p] = s[p];
-    }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var base_1 = require("../base");
-var values_1 = require("../values");
-var inputs_1 = require("../inputs");
-var utils_1 = require("../utils");
-var typeDefs_1 = require("../utils/typeDefs");
-var List = (function (_super) {
-    __extends(List, _super);
-    function List(options) {
-        var _this = _super.call(this, options) || this;
-        _this.type = List.type;
-        _this.valueTypeDef = function () {
-            var declarations = [];
-            declarations = declarations.concat(typeDefs_1.getDefsFromInputs(_this.itemSchema.filter(inputs_1.isInput)));
-            return {
-                id: _this.id,
-                typeDef: "{" + typeDefs_1.defsMapToString(declarations) + ", __id: string | undefined}[]"
-            };
-        };
-        _this.itemSchema = options.itemSchema;
-        _this.description = options.description;
-        _this.range = options.range;
-        _this.itemDisplayClass = options.itemDisplayClass;
-        _this.itemDisplayAttributes = options.itemDisplayAttributes;
-        _this.sortable = options.sortable;
-        _this.showItemId = options.showItemId;
-        return _this;
-    }
-    List.prototype.validate = function (value, ctx) {
-        var _this = this;
-        // Min
-        if (this.range && this.range.min) {
-            if (!value || value.length < this.range.min) {
-                return [{ type: 'Min', payload: this.range.min }];
-            }
-        }
-        // Max
-        if (this.range && this.range.max) {
-            if (value && value.length > this.range.max) {
-                return [{ type: 'Max', payload: this.range.max }];
-            }
-        }
-        // No value, then is valid.
-        if (!value)
-            return {};
-        // Not a valid value.
-        if (!this.isValidValue(value))
-            return [{ type: 'InvalidListValue' }];
-        var itemsErrors = {};
-        value && value.map(function (item, index) {
-            var itemErrors = _this.validateItem(item, ctx);
-            var itemId = item.__id || index;
-            itemsErrors[itemId] = itemErrors;
-        });
-        return itemsErrors;
-    };
-    List.prototype.validateItem = function (value, ctx) {
-        var itemError = {};
-        if (value.__id) {
-            var itemErrors_1 = {};
-            this.itemSchema.forEach(function (input) {
-                if (inputs_1.isInput(input)) {
-                    itemErrors_1[input.id] = input.validate(value[input.id], ctx);
-                }
-            });
-            return itemErrors_1;
-        }
-        else {
-            return [{ type: 'ItemHasNoUniqueId' }];
-        }
-    };
-    List.prototype.isValidValue = function (v) {
-        return v && Array.isArray(v);
-    };
-    List.fromJSON = function (value) {
-        return new List(__assign({}, value, { range: value.range && values_1.RangeValue.fromJSON(value.range) || undefined, itemSchema: value.itemSchema.map(function (i) {
-                return utils_1.createComponentFromJSON(i.type, i);
-            }) }));
-    };
-    List.isInstance = function (instance) {
-        return instance.type === List.type;
-    };
-    List.type = 'list';
-    return List;
-}(base_1.BaseElement));
-exports.List = List;
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.List = void 0;
+var base_1 = require("../base");
+var values_1 = require("../values");
+var inputs_1 = require("../inputs");
+var typeDefs_1 = require("../utils/typeDefs");
+var List = /** @class */ (function (_super) {
+    __extends(List, _super);
+    function List(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = List.type;
+        _this.valueTypeDef = function () {
+            var declarations = [];
+            declarations = declarations.concat(typeDefs_1.getDefsFromInputs(_this.itemSchema.filter(inputs_1.isInput)));
+            return {
+                id: _this.id,
+                typeDef: "{" + typeDefs_1.defsMapToString(declarations) + ", __id: string | undefined}[]"
+            };
+        };
+        _this.itemSchema = options.itemSchema;
+        _this.description = options.description;
+        _this.range = options.range;
+        _this.itemDisplayClass = options.itemDisplayClass;
+        _this.itemDisplayAttributes = options.itemDisplayAttributes;
+        _this.sortable = options.sortable;
+        _this.showItemId = options.showItemId;
+        return _this;
+    }
+    List.prototype.validate = function (value, ctx) {
+        var _this = this;
+        // Min
+        if (this.range && this.range.min) {
+            if (!value || value.length < this.range.min) {
+                return [{ type: 'Min', payload: this.range.min }];
+            }
+        }
+        // Max
+        if (this.range && this.range.max) {
+            if (value && value.length > this.range.max) {
+                return [{ type: 'Max', payload: this.range.max }];
+            }
+        }
+        // No value, then is valid.
+        if (!value)
+            return {};
+        // Not a valid value.
+        if (!this.isValidValue(value))
+            return [{ type: 'InvalidListValue' }];
+        var itemsErrors = {};
+        value && value.map(function (item, index) {
+            var itemErrors = _this.validateItem(item, ctx);
+            var itemId = item.__id || index;
+            itemsErrors[itemId] = itemErrors;
+        });
+        return itemsErrors;
+    };
+    List.prototype.validateItem = function (value, ctx) {
+        var itemError = {};
+        if (value.__id) {
+            var itemErrors_1 = {};
+            this.itemSchema.forEach(function (input) {
+                if (inputs_1.isInput(input)) {
+                    itemErrors_1[input.id] = input.validate(value[input.id], ctx);
+                }
+            });
+            return itemErrors_1;
+        }
+        else {
+            return [{ type: 'ItemHasNoUniqueId' }];
+        }
+    };
+    List.prototype.isValidValue = function (v) {
+        return v && Array.isArray(v);
+    };
+    List.fromJSON = function (value) {
+        var createComponentFromJSON = require('../utils').default;
+        return new List(__assign(__assign({}, value), { range: value.range && values_1.RangeValue.fromJSON(value.range) || undefined, itemSchema: value.itemSchema.map(function (i) {
+                return createComponentFromJSON(i.type, i);
+            }) }));
+    };
+    List.isInstance = function (instance) {
+        return instance.type === List.type;
+    };
+    List.type = 'list';
+    return List;
+}(base_1.BaseElement));
+exports.List = List;

package/dist/lib/errors.d.ts

@@ -1,22 +1,22 @@
-export declare namespace ValueError {
-    type Required = SimpleValueError<'required'>;
-    type Min = PayloadValueError<'min', number>;
-    type Max = PayloadValueError<'max', number>;
-    type InvalidValue = SimpleValueError<'invalidValue'>;
-}
-export interface SimpleValueError<E extends string> {
-    type: E;
-}
-export interface PayloadValueError<E extends string, P> extends SimpleValueError<E> {
-    payload: P;
-}
-export declare type ValueError<E extends string = string, P = {}> = SimpleValueError<E> | PayloadValueError<E, P>;
-export declare namespace Errors {
-    const isMap: (errors: Errors<ValueError<string, {}>>) => errors is ErrorsMap<ValueError<string, {}>>;
-    const isArray: (errors: Errors<ValueError<string, {}>>) => errors is ValueError<string, {}>[];
-    const any: (errors: ErrorsMap<ValueError<string, {}>> | ValueError<string, {}>[] | undefined) => boolean;
-}
-export declare type Errors<E extends ValueError = ValueError> = E[] | ErrorsMap;
-export interface ErrorsMap<E extends ValueError = ValueError> {
-    [id: string]: Errors | undefined;
-}
+export declare namespace ValueError {
+    type Required = SimpleValueError<'required'>;
+    type Min = PayloadValueError<'min', number>;
+    type Max = PayloadValueError<'max', number>;
+    type InvalidValue = SimpleValueError<'invalidValue'>;
+}
+export interface SimpleValueError<E extends string> {
+    type: E;
+}
+export interface PayloadValueError<E extends string, P> extends SimpleValueError<E> {
+    payload: P;
+}
+export declare type ValueError<E extends string = string, P = {}> = SimpleValueError<E> | PayloadValueError<E, P>;
+export declare namespace Errors {
+    const isMap: (errors: Errors) => errors is ErrorsMap<ValueError<string, {}>>;
+    const isArray: (errors: Errors) => errors is ValueError<string, {}>[];
+    const any: (errors: Errors | undefined) => boolean;
+}
+export declare type Errors<E extends ValueError = ValueError> = E[] | ErrorsMap;
+export interface ErrorsMap<E extends ValueError = ValueError> {
+    [id: string]: Errors | undefined;
+}

package/dist/lib/errors.js

@@ -1,23 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var Errors;
-(function (Errors) {
-    Errors.isMap = function (errors) {
-        return !Array.isArray(errors);
-    };
-    Errors.isArray = function (errors) {
-        return Array.isArray(errors);
-    };
-    Errors.any = function (errors) {
-        if (!errors)
-            return false;
-        if (Array.isArray(errors)) {
-            return errors.length > 0;
-        }
-        else {
-            return Object.keys(errors).some(function (k) {
-                return Errors.any(errors[k]);
-            });
-        }
-    };
-})(Errors = exports.Errors || (exports.Errors = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Errors = void 0;
+var Errors;
+(function (Errors) {
+    Errors.isMap = function (errors) {
+        return !Array.isArray(errors);
+    };
+    Errors.isArray = function (errors) {
+        return Array.isArray(errors);
+    };
+    Errors.any = function (errors) {
+        if (!errors)
+            return false;
+        if (Array.isArray(errors)) {
+            return errors.length > 0;
+        }
+        else {
+            return Object.keys(errors).some(function (k) {
+                return Errors.any(errors[k]);
+            });
+        }
+    };
+})(Errors = exports.Errors || (exports.Errors = {}));