@vixoniccom/modules 2.11.0

package/dist/lib/inputs/text-input.js

@@ -0,0 +1,64 @@
+"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 validation_1 = require("../utils/validation");
+var TextInput = (function (_super) {
+    __extends(TextInput, _super);
+    function TextInput(options) {
+        var _this = _super.call(this, options) || this;
+        _this.type = TextInput.type;
+        _this.valueTypeDef = function () { return 'string'; };
+        _this.description = options.description;
+        _this.required = options.required;
+        _this.pattern = options.pattern;
+        _this.displayFormat = options.displayFormat;
+        _this.range = options.range;
+        return _this;
+    }
+    TextInput.prototype.validateInput = function (value) {
+        var errors = [];
+        errors = errors.concat(validation_1.Validator.required(value, this.required));
+        if (this.pattern && value) {
+            var reg = new RegExp(this.pattern);
+            if (!reg.exec(value))
+                errors = errors.concat({ type: 'pattern' });
+        }
+        if (this.range) {
+            var length = value && value.length || 0;
+            errors = errors.concat(validation_1.Validator.min(length, this.range.min));
+            errors = errors.concat(validation_1.Validator.max(length, this.range.max));
+        }
+        return errors;
+    };
+    TextInput.prototype.isValidValue = function (v) {
+        return typeof v === 'string';
+    };
+    TextInput.fromJSON = function (value) {
+        return new TextInput(this.parseJSON(value));
+    };
+    TextInput.parseJSON = function (value) {
+        return __assign({}, value, { range: value.range && values_1.RangeValue.fromJSON(value.range) || undefined });
+    };
+    TextInput.type = 'text-input';
+    return TextInput;
+}(base_1.Input));
+exports.TextInput = TextInput;

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

@@ -0,0 +1,4 @@
+import { Label } from './label';
+export declare const allUIComponents: typeof Label[];
+export declare type UIComponent = Label;
+export { Label };

package/dist/lib/ui/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var label_1 = require("./label");
+exports.Label = label_1.Label;
+exports.allUIComponents = [label_1.Label];

package/dist/lib/ui/label.d.ts

@@ -0,0 +1,18 @@
+import { ConfigurationElement } from '../base';
+export declare class Label extends ConfigurationElement {
+    static type: string;
+    type: string;
+    readonly label: string;
+    readonly description?: string;
+    readonly show?: string;
+    constructor(options: {
+        label: string;
+        description?: string;
+        show?: string;
+    });
+    static fromJSON(value: {
+        label: string;
+        description?: string;
+        show?: string;
+    }): Label;
+}

package/dist/lib/ui/label.js

@@ -0,0 +1,30 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var base_1 = require("../base");
+var Label = (function (_super) {
+    __extends(Label, _super);
+    function Label(options) {
+        var _this = _super.call(this) || this;
+        _this.type = Label.type;
+        _this.label = options.label;
+        _this.description = options.description;
+        _this.show = options.show;
+        return _this;
+    }
+    Label.fromJSON = function (value) {
+        return new Label(value);
+    };
+    Label.type = 'label';
+    return Label;
+}(base_1.ConfigurationElement));
+exports.Label = Label;

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

@@ -0,0 +1 @@
+export declare const createComponentFromJSON: (type: string, value: any) => any;

package/dist/lib/utils/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ui_1 = require("../ui");
+var inputs_1 = require("../inputs");
+var containers_1 = require("../containers");
+var allComponents = inputs_1.allInputs.concat(ui_1.allUIComponents, containers_1.allContainer);
+exports.createComponentFromJSON = function (type, value) {
+    var component = allComponents.find(function (i) {
+        return (i.type === type);
+    });
+    if (component) {
+        if (component.fromJSON) {
+            return component.fromJSON(value);
+        }
+        else {
+            throw new Error("Component \"" + type + "\" does not implement fromJSON");
+        }
+    }
+    else {
+        throw new Error("Invalid component \"" + type + "\"");
+    }
+};

package/dist/lib/utils/typeDefs.d.ts

@@ -0,0 +1,7 @@
+import { InputComponent } from "../index";
+export declare type TypeDefMap = {
+    id: string;
+    typeDef: string;
+};
+export declare function getDefsFromInputs(inputs: InputComponent[]): TypeDefMap[];
+export declare function defsMapToString(defsMap: TypeDefMap[]): string;

package/dist/lib/utils/typeDefs.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getDefsFromInputs(inputs) {
+    return inputs.map(function (i) { return ({ id: i.id, typeDef: i.valueTypeDef() }); });
+}
+exports.getDefsFromInputs = getDefsFromInputs;
+function defsMapToString(defsMap) {
+    var reduced = [];
+    return defsMap.reduce(function (pV, e) {
+        var exist = pV.findIndex(function (iE) { return iE.id === e.id; });
+        if (exist !== -1) {
+            pV[exist].typeDef = pV[exist].typeDef + " | " + e.typeDef;
+            return pV;
+        }
+        return pV.concat(e);
+    }, reduced).map(function (e) { return e.id + ": " + e.typeDef; }).join(', ');
+}
+exports.defsMapToString = defsMapToString;

package/dist/lib/utils/validation.d.ts

@@ -0,0 +1,7 @@
+import { SimpleValueError, PayloadValueError } from "../errors";
+export declare namespace Validator {
+    const required: (value: any, required: boolean | undefined, onlyUndefined?: boolean) => SimpleValueError<"required">[];
+    const min: (value: number, min: number | undefined) => PayloadValueError<"min", number>[];
+    const max: (value: number, max: number | undefined) => PayloadValueError<"max", number>[];
+    const invalidValue: () => SimpleValueError<"invalidValue">[];
+}

package/dist/lib/utils/validation.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Validator;
+(function (Validator) {
+    Validator.required = function (value, required, onlyUndefined) {
+        if (onlyUndefined === void 0) { onlyUndefined = false; }
+        if ((value === undefined
+            || (!onlyUndefined && (typeof value === 'string' && value === '')))
+            && required)
+            return [{ type: 'required' }];
+        return [];
+    };
+    Validator.min = function (value, min) {
+        if (min && value < min)
+            return [{ type: 'min', payload: min }];
+        return [];
+    };
+    Validator.max = function (value, max) {
+        if (max && value > max)
+            return [{ type: 'max', payload: max }];
+        return [];
+    };
+    Validator.invalidValue = function () {
+        return [{ type: 'invalidValue' }];
+    };
+})(Validator = exports.Validator || (exports.Validator = {}));

package/dist/lib/values.d.ts

@@ -0,0 +1,21 @@
+export declare class RangeValue {
+    readonly min: number | undefined;
+    readonly max: number | undefined;
+    constructor(min?: number | undefined, max?: number | undefined);
+    static fromJSON(value: string): RangeValue;
+    protected static parseNumber(value: string): number | undefined;
+    toJSON(): string;
+}
+export declare class NumberRangeValue extends RangeValue {
+    readonly step: number | undefined;
+    constructor(min?: number, max?: number, step?: number | undefined);
+    static fromJSON(value: string): NumberRangeValue;
+    toJSON(): string;
+}
+export declare class DateRangeValue {
+    readonly min: string | undefined;
+    readonly max: string | undefined;
+    constructor(min?: string | undefined, max?: string | undefined);
+    static fromJSON(value: string): DateRangeValue;
+    toJSON(): string;
+}

package/dist/lib/values.js

@@ -0,0 +1,86 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var RangeValue = (function () {
+    function RangeValue(min, max) {
+        this.min = min;
+        this.max = max;
+    }
+    RangeValue.fromJSON = function (value) {
+        var reg = new RegExp(/\[(.*):(.*)]/g);
+        var match = reg.exec(value);
+        var min;
+        var max;
+        if (match && match.length > 1) {
+            min = this.parseNumber(match[1]);
+            max = this.parseNumber(match[2]);
+        }
+        return new RangeValue(min, max);
+    };
+    RangeValue.parseNumber = function (value) {
+        var p = value !== '' ? Number(value) : undefined;
+        return p !== undefined && !isNaN(p) ? p : undefined;
+    };
+    RangeValue.prototype.toJSON = function () {
+        return "[" + (this.min !== undefined ? this.min : '') + ":" + (this.max !== undefined ? this.max : '') + "]";
+    };
+    return RangeValue;
+}());
+exports.RangeValue = RangeValue;
+var NumberRangeValue = (function (_super) {
+    __extends(NumberRangeValue, _super);
+    function NumberRangeValue(min, max, step) {
+        var _this = _super.call(this, min, max) || this;
+        _this.step = step;
+        return _this;
+    }
+    NumberRangeValue.fromJSON = function (value) {
+        var reg = new RegExp(/\[(.*):(.*):(.*)]/g);
+        var match = reg.exec(value);
+        var min;
+        var max;
+        var step;
+        if (match && match.length > 2) {
+            min = this.parseNumber(match[1]);
+            max = this.parseNumber(match[2]);
+            step = this.parseNumber(match[3]);
+        }
+        return new NumberRangeValue(min, max, step);
+    };
+    NumberRangeValue.prototype.toJSON = function () {
+        return "[" + (this.min !== undefined ? this.min : '') + ":" + (this.max !== undefined ? this.max : '') + ":" + (this.step !== undefined ? this.step : '') + "]";
+    };
+    return NumberRangeValue;
+}(RangeValue));
+exports.NumberRangeValue = NumberRangeValue;
+var DateRangeValue = (function () {
+    function DateRangeValue(min, max) {
+        this.min = min;
+        this.max = max;
+    }
+    DateRangeValue.fromJSON = function (value) {
+        var reg = new RegExp(/\[(.*):(.*)]/g);
+        var match = reg.exec(value);
+        var min;
+        var max;
+        if (match && match.length > 2) {
+            min = match[1];
+            max = match[2];
+        }
+        return new DateRangeValue(min, max);
+    };
+    DateRangeValue.prototype.toJSON = function () {
+        return "[" + (this.min !== undefined ? this.min : '') + ":" + (this.max !== undefined ? this.max : '') + "]";
+    };
+    return DateRangeValue;
+}());
+exports.DateRangeValue = DateRangeValue;

package/dist/lib/visibility.d.ts

@@ -0,0 +1,2 @@
+import { Configuration } from ".";
+export declare function shouldBeVisible(item: any, _values: Configuration.Value): boolean;

package/dist/lib/visibility.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function shouldBeVisible(item, _values) {
+    if (!item.show)
+        return true;
+    var jsEval = item.show;
+    try {
+        var regexp = new RegExp('{{(.*?)}}', 'ig');
+        jsEval = jsEval.replace(regexp, "_values.$1");
+        // tslint:disable-next-line
+        var show = eval(jsEval);
+        return show === true;
+    }
+    catch (e) {
+        console.warn('Unable to parse expression:', jsEval);
+        console.warn(e);
+        return true;
+    }
+}
+exports.shouldBeVisible = shouldBeVisible;

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@vixoniccom/modules",
+  "version": "2.11.0",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "build": "tsc",
+    "release": "standard-version",
+    "test": "ts-node ./test/index.ts"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^8.0.51",
+    "jest": "^23.6.0",
+    "standard-version": "^4.4.0",
+    "ts-node": "^7.0.1",
+    "typescript": "^2.4.2"
+  }
+}