ax-common-ui-lib 1.0.0-beta.0

package/esm2020/lib/forms/page/widgets/textbox.mjs

@@ -0,0 +1,338 @@
+var TextBox_1;
+import { __decorate, __metadata } from "tslib";
+import { Constants } from '../common/constants';
+import { Widget } from './widget';
+import { JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';
+import { Case, WidgetType } from '../common/widget-enums';
+import { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';
+import { TextBoxMaskConverter } from '../value-converters/textBox-mask-converter';
+import { ValueWithoutMaskConverter } from '../value-converters/value-without-mask-converter';
+import { PropertyPanelField } from '../common/property-panel-field';
+import { TextBoxComponent } from '../../../sculptor-lib/widgets/textbox/textbox.component';
+let TextBox = TextBox_1 = class TextBox extends Widget {
+    constructor(field) {
+        super(field);
+        this.component = TextBoxComponent;
+        this.value = null;
+        this.widgetIcon = 'axo_square_text';
+        this.inputType = '';
+        this.mask = null;
+        this.saveNumber = '1';
+        this.valueWithoutMask = '';
+        this.markup = '';
+        this.unit = '';
+        this.multiSelect = false;
+        if (field) {
+            this.textBox(field);
+        }
+        else {
+            this.newTextBox();
+        }
+    }
+    /**
+     * get widget value
+     *
+     * @returns
+     */
+    getWidgetValue() {
+        return this.value;
+    }
+    /**
+     * Set widget Value
+     *
+     * @param value
+     */
+    setWidgetValue(value) {
+        this.value = value;
+    }
+    /**
+     * this will return serialize of widget
+     */
+    getWidgetSerializedValue() {
+        if (this.value) {
+            return this.value.toString();
+        }
+        else {
+            return '';
+        }
+    }
+    /**function to create text-box object with existing values
+    *
+    *@param field
+    *
+    */
+    textBox(field) {
+        this.inputType = field[Constants.INPUT_TYPE];
+        this.minLength = field[Constants.MAX_LENGTH];
+        this.maxLength = field[Constants.MIN_LENGTH];
+        this.mask = field.mask;
+        this.isMultiline = field.isMultiline;
+        this.case = field.case;
+        this.defaultCase = field.defaultCase;
+        this.onValueEdit = field.onValueEdit;
+        this.choices = field.choices;
+        this.defaultText = field.defaultText;
+        this.otherMask = field.otherMask;
+        this.isOtpVerificationRequired = field.isOtpVerificationRequired;
+        this.validityDependents = field.validityDependents;
+        this.mastringType = field.mastringType;
+        this.maxDecimal = field.maxDecimal;
+        this.minNumber = field.minNumber;
+        this.allowMultipleEmails = field.allowMultipleEmails;
+        this.saveNumber = field.saveNumber;
+        this.maxNumber = field.maxNumber;
+        this.dependants = field.dependants;
+        this.submitWithoutVerification = field.submitWithoutVerification;
+        this.valueWithoutMask = field.valueWithoutMask;
+        this.unit = field.unit;
+        this.multiSelect = field.multiSelect;
+        this.name = 'TextBox';
+    }
+    // Function to create new text-box object
+    newTextBox() {
+        this.inputType = 'text';
+        this.minLength = null;
+        this.maxLength = 1000;
+        this.mask = 'none';
+        this.isMultiline = false;
+        this.case = null;
+        this.defaultCase = null;
+        this.onValueEdit = null;
+        this.choices = null;
+        this.defaultText = null;
+        this.otherMask = null;
+        this.isOtpVerificationRequired = false;
+        this.validityDependents = null;
+        this.mastringType = null;
+        this.maxDecimal = '2';
+        this.minNumber = '0';
+        this.allowMultipleEmails = false;
+        this.saveNumber = '1';
+        this.maxNumber = '999999';
+        this.dependants = null;
+        this.submitWithoutVerification = '1';
+        this.valueWithoutMask = '';
+        this.type = WidgetType.textBox;
+        this.identifier = 'textBox';
+        this.unit = null;
+        this.multiSelect = false;
+        this.name = 'TextBox';
+    }
+    // Method to retrieve UI metadata for a property
+    static getPropertyPanelFieldMetadata(target, key) {
+        return Reflect.getMetadata(key, target);
+    }
+    // Method to retrieve UI metadata for all properties
+    getPropertyPanelFieldUIProperties() {
+        const properties = {};
+        const indexMap = new Map();
+        // Get the list of property  names using Object.getOwnPropertyNames
+        const propertyNames = Object.getOwnPropertyNames(this);
+        const prop = []; // to hold sorted property names
+        const newProp = []; // to hold property names without sortIndex
+        // Loop through each property name and retrieve the UI metadata using getUIPrPropertyPanelFieldMetadata
+        for (const propertyName of propertyNames) {
+            const metadata = TextBox_1.getPropertyPanelFieldMetadata(this, propertyName);
+            if (metadata) {
+                properties[propertyName] = metadata;
+                if (metadata.sortIndex) {
+                    prop.splice(metadata.sortIndex, 0, propertyName);
+                }
+                else {
+                    newProp.push(propertyName);
+                }
+            }
+        }
+        const data = {
+            properties: properties,
+            keys: prop.concat(newProp)
+        };
+        return data;
+    }
+};
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Input Type',
+        choices: [{ value: 'email', text: 'Email' },
+            { value: 'numeric', text: 'Numeric' }, { value: 'decimal', text: 'Decimal' },
+            { value: 'address', text: 'Address' }, { value: 'text', text: 'Plain Text' }, { value: 'phone', text: 'Phone' }],
+        required: true, helpText: 'Select Input Type', sortIndex: 1
+    }),
+    JsonProperty(Constants.inputType, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "inputType", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'number', label: 'Minimum Length', conditionInputType: 'inputType', conditionInputData: ['text'],
+        helpText: 'Select Minimum Length', sortIndex: 9, colSpan: 50
+    }),
+    JsonProperty(Constants.minLength, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], TextBox.prototype, "minLength", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'number', label: 'Maximum Length', conditionInputType: 'inputType', conditionInputData: ['text'],
+        helpText: 'Select Maximum Length', sortIndex: 10, colSpan: 50
+    }),
+    JsonProperty(Constants.maxLength, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Number)
+], TextBox.prototype, "maxLength", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Mask',
+        choices: [{ value: '', text: 'None' }, { value: 'date', text: 'Date (15/08/1947)' },
+            { value: 'hour', text: 'Hour (12:00)' }, { value: 'date_hour', text: 'Date & Hour (15/08/1947 12:00)' },
+            { value: 'zip_code', text: 'ZIP Code (12345-678)' }, { value: 'crazy_zip_code', text: 'Crazy ZIP Code (1-23-45-67)' },
+            { value: 'telephone', text: 'Telephone (1234-5678)' }, { value: 'telephone_with_code_area', text: 'Telephone with Code Area ((02) 4021-2265)' },
+            { value: 'us_telephone', text: 'US Telephone ((123) 456-7899)' }, { value: 'ip_address', text: 'IP Address (127.000.000.001)' },
+            { value: 'money', text: 'Money (1.000,00)' }, { value: 'other', text: 'Other' }],
+        conditionInputType: 'inputType', conditionInputData: ['text', 'phone'],
+        helpText: 'Select User Input Format', sortIndex: 5
+    }),
+    JsonProperty('mask', TextBoxMaskConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "mask", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'is Multiline', conditionInputType: 'inputType', conditionInputData: ['text'],
+        helpText: 'Allow multiline', sortIndex: 7
+    }),
+    JsonProperty(Constants.isMultiline, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], TextBox.prototype, "isMultiline", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Case', choices: [{ value: '', text: '' },
+            { value: 'capital', text: 'Capital' }, { value: 'small', text: 'Small' }, { value: 'title', text: 'Title' }],
+        conditionInputType: 'inputType', conditionInputData: ['text'], helpText: 'Select Case', sortIndex: 11
+    }),
+    JsonProperty('case', String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "case", void 0);
+__decorate([
+    JsonProperty(Constants.defaultCase, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "defaultCase", void 0);
+__decorate([
+    PropertyPanelField({ inputType: 'text', label: 'On Value Edit', helpText: 'This function will be called on every character change in the text' }),
+    JsonProperty(Constants.onValueEdit, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "onValueEdit", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Choices (default)', conditionInputType: 'inputType',
+        conditionInputData: ['numeric', 'decimal', 'address', 'text', 'phone'],
+        helpText: 'Enter choices, one per line'
+    }),
+    JsonProperty(Constants.choices, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "choices", void 0);
+__decorate([
+    PropertyPanelField({ inputType: 'text', label: 'Default text', helpText: 'Enter Default Text', sortIndex: 14 }),
+    JsonProperty(Constants.defaultText, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "defaultText", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Enter other mask', conditionInputType: 'mask', conditionInputData: ['other'],
+        helpText: 'Enter other mask', sortIndex: 6
+    }),
+    JsonProperty(Constants.otherMask, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "otherMask", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'OTP Verification	', conditionInputType: 'inputType', conditionInputData: ['phone'],
+        helpText: 'Required OTP verification', sortIndex: 2
+    }),
+    JsonProperty(Constants.isOtpVerificationRequired, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], TextBox.prototype, "isOtpVerificationRequired", void 0);
+__decorate([
+    JsonProperty(Constants.validityDependents, [], PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Array)
+], TextBox.prototype, "validityDependents", void 0);
+__decorate([
+    JsonProperty(Constants.mastringType, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "mastringType", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'number', label: 'Decimal Places', conditionInputType: 'inputType', conditionInputData: ['decimal'],
+        helpText: 'Select Maximum Digits after decimal point', sortIndex: 15
+    }),
+    JsonProperty(Constants.maxDecimal, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "maxDecimal", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'number', label: 'Minimum Number', conditionInputType: 'inputType', conditionInputData: ['numeric'],
+        helpText: 'Select Minimum Number', sortIndex: 12
+    }),
+    JsonProperty(Constants.minNumber, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "minNumber", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Allow Multiple Email IDs?', conditionInputType: 'inputType', conditionInputData: ['email'],
+        helpText: 'Allow Multiple Email ID\'s', sortIndex: 8
+    }),
+    JsonProperty(Constants.allowMultipleEmails, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], TextBox.prototype, "allowMultipleEmails", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: '  Save number', conditionInputType: 'inputType', conditionInputData: ['phone'],
+        helpText: 'Save the phone number on the server', sortIndex: 4
+    }),
+    JsonProperty(Constants.saveNumber, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "saveNumber", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'number', label: 'Maximum Number', conditionInputType: 'inputType', conditionInputData: ['numeric'],
+        helpText: 'The maximum limit for the number can be 2147483647', sortIndex: 13
+    }),
+    JsonProperty(Constants.maxNumber, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "maxNumber", void 0);
+__decorate([
+    JsonProperty(Constants.dependants, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "dependants", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Verification Mandatory?', conditionInputType: 'isOtpVerificationRequired', conditionInputData: ['true'],
+        helpText: 'Submit record without OTP verification', sortIndex: 3
+    }),
+    JsonProperty(Constants.submitWithoutVerification, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "submitWithoutVerification", void 0);
+__decorate([
+    JsonProperty(Constants.valueWithoutMask, ValueWithoutMaskConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "valueWithoutMask", void 0);
+__decorate([
+    JsonProperty(Constants.markup, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "markup", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'text', label: 'Unit', conditionInputType: 'inputType', conditionInputData: ['numeric', 'decimal'],
+        helpText: 'Select unit'
+    }),
+    JsonProperty(Constants.unit, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TextBox.prototype, "unit", void 0);
+__decorate([
+    PropertyPanelField({ inputType: 'toggle', label: 'Multiple Selection', conditionInputType: 'inputType', conditionInputData: ['text'],
+        helpText: 'Allow selecting multiple choices or only one?' }),
+    JsonProperty(Constants.multiSelect, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], TextBox.prototype, "multiSelect", void 0);
+TextBox = TextBox_1 = __decorate([
+    JsonObject('TextBox'),
+    __metadata("design:paramtypes", [Object])
+], TextBox);
+export { TextBox };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"textbox.js","sourceRoot":"","sources":["../../../../../../../src/ax-common-ui-lib/src/lib/forms/page/widgets/textbox.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/member-ordering */\nimport { Type } from '@angular/core';\nimport { Constants } from '../common/constants';\nimport { Widget } from './widget';\nimport { JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';\nimport { Case, WidgetType } from '../common/widget-enums';\nimport { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';\nimport { TextBoxMaskConverter } from '../value-converters/textBox-mask-converter';\nimport { ValueWithoutMaskConverter } from '../value-converters/value-without-mask-converter';\nimport { PropertyPanelField, PropertyPanelFieldMetadata } from '../common/property-panel-field';\nimport { TextBoxComponent } from '../../../sculptor-lib/widgets/textbox/textbox.component';\n\ntype TextBoxValueValue = Type<string | number>;\n@JsonObject('TextBox')\nexport class TextBox extends Widget {\n  component: Type<TextBoxComponent> = TextBoxComponent;\n\n\n  value: TextBoxValueValue = null;\n  widgetIcon: string = 'axo_square_text';\n\n  @PropertyPanelField({\n    inputType: 'select', label: 'Input Type',\n    choices: [{ value: 'email', text: 'Email' },\n    { value: 'numeric', text: 'Numeric' }, { value: 'decimal', text: 'Decimal' },\n    { value: 'address', text: 'Address' }, { value: 'text', text: 'Plain Text' }, { value: 'phone', text: 'Phone' }],\n    required: true, helpText: 'Select Input Type', sortIndex: 1\n  })\n  @JsonProperty(Constants.inputType, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  inputType: string = '';\n\n  @PropertyPanelField({\n    inputType: 'number', label: 'Minimum Length', conditionInputType: 'inputType', conditionInputData: ['text'],\n    helpText: 'Select Minimum Length', sortIndex: 9, colSpan:50\n  })\n  @JsonProperty(Constants.minLength, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  minLength: number;\n\n  @PropertyPanelField({\n    inputType: 'number', label: 'Maximum Length', conditionInputType: 'inputType', conditionInputData: ['text'],\n    helpText: 'Select Maximum Length', sortIndex: 10, colSpan:50\n  })\n  @JsonProperty(Constants.maxLength, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  maxLength: number;\n\n  @PropertyPanelField({\n    inputType: 'select', label: 'Mask',\n    choices: [{ value: '', text: 'None' }, { value: 'date', text: 'Date (15/08/1947)' },\n    { value: 'hour', text: 'Hour (12:00)' }, { value: 'date_hour', text: 'Date & Hour (15/08/1947 12:00)' },\n    { value: 'zip_code', text: 'ZIP Code (12345-678)' }, { value: 'crazy_zip_code', text: 'Crazy ZIP Code (1-23-45-67)' },\n    { value: 'telephone', text: 'Telephone (1234-5678)' }, { value: 'telephone_with_code_area', text: 'Telephone with Code Area ((02) 4021-2265)' },\n    { value: 'us_telephone', text: 'US Telephone ((123) 456-7899)' }, { value: 'ip_address', text: 'IP Address (127.000.000.001)' },\n    { value: 'money', text: 'Money (1.000,00)' }, { value: 'other', text: 'Other' }],\n    conditionInputType: 'inputType', conditionInputData: ['text', 'phone'],\n    helpText: 'Select User Input Format', sortIndex: 5\n  })\n  @JsonProperty('mask', TextBoxMaskConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n  mask: string = null;\n\n  @PropertyPanelField({\n    inputType: 'toggle', label: 'is Multiline', conditionInputType: 'inputType', conditionInputData: ['text'],\n    helpText: 'Allow multiline', sortIndex: 7\n  })\n  @JsonProperty(Constants.isMultiline, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n  isMultiline: boolean;\n\n  @PropertyPanelField({\n    inputType: 'select', label: 'Case', choices: [{ value: '', text: '' },\n    { value: 'capital', text: 'Capital' }, { value: 'small', text: 'Small' }, { value: 'title', text: 'Title' }],\n    conditionInputType: 'inputType', conditionInputData: ['text'], helpText: 'Select Case', sortIndex: 11\n  })\n  @JsonProperty('case', String, PropertyConvertingMode.IGNORE_NULLABLE)\n  case: Case;\n\n  @JsonProperty(Constants.defaultCase, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  defaultCase: string;\n\n  @PropertyPanelField({ inputType: 'text', label: 'On Value Edit', helpText: 'This function will be called on every character change in the text' })\n  @JsonProperty(Constants.onValueEdit, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  onValueEdit: string;\n\n  @PropertyPanelField({\n    inputType: 'text', label: 'Choices (default)', conditionInputType: 'inputType',\n    conditionInputData: ['numeric', 'decimal', 'address', 'text', 'phone'],\n    helpText: 'Enter choices, one per line'\n  })\n  @JsonProperty(Constants.choices, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  choices: string;\n\n  @PropertyPanelField({ inputType: 'text', label: 'Default text', helpText: 'Enter Default Text', sortIndex: 14 })\n  @JsonProperty(Constants.defaultText, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  defaultText: string;\n\n  @PropertyPanelField({\n    inputType: 'text', label: 'Enter other mask', conditionInputType: 'mask', conditionInputData: ['other'],\n    helpText: 'Enter other mask', sortIndex: 6\n  })\n  @JsonProperty(Constants.otherMask, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  otherMask: string;\n\n  @PropertyPanelField({\n    inputType: 'toggle', label: 'OTP Verification\t', conditionInputType: 'inputType', conditionInputData: ['phone'],\n    helpText: 'Required OTP verification', sortIndex: 2\n  })\n  @JsonProperty(Constants.isOtpVerificationRequired, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  isOtpVerificationRequired: boolean;\n\n  @JsonProperty(Constants.validityDependents, [], PropertyConvertingMode.IGNORE_NULLABLE)\n  validityDependents: [];\n\n  @JsonProperty(Constants.mastringType, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  mastringType: string;\n\n  @PropertyPanelField({\n    inputType: 'number', label: 'Decimal Places', conditionInputType: 'inputType', conditionInputData: ['decimal'],\n    helpText: 'Select Maximum Digits after decimal point', sortIndex: 15\n  })\n  @JsonProperty(Constants.maxDecimal, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  maxDecimal: string;\n\n  @PropertyPanelField({\n    inputType: 'number', label: 'Minimum Number', conditionInputType: 'inputType', conditionInputData: ['numeric'],\n    helpText: 'Select Minimum Number', sortIndex: 12\n  })\n  @JsonProperty(Constants.minNumber, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  minNumber: string;\n\n\n  @PropertyPanelField({\n    inputType: 'toggle', label: 'Allow Multiple Email IDs?', conditionInputType: 'inputType', conditionInputData: ['email'],\n    helpText: 'Allow Multiple Email ID\\'s', sortIndex: 8\n  })\n  @JsonProperty(Constants.allowMultipleEmails, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n  allowMultipleEmails: boolean;\n\n  @PropertyPanelField({\n    inputType: 'toggle', label: '  Save number', conditionInputType: 'inputType', conditionInputData: ['phone'],\n    helpText: 'Save the phone number on the server', sortIndex: 4\n  })\n  @JsonProperty(Constants.saveNumber, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  saveNumber: string = '1';\n\n  @PropertyPanelField({\n    inputType: 'number', label: 'Maximum Number', conditionInputType: 'inputType', conditionInputData: ['numeric'],\n    helpText: 'The maximum limit for the number can be 2147483647', sortIndex: 13\n  })\n  @JsonProperty(Constants.maxNumber, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  maxNumber: string;\n\n  @JsonProperty(Constants.dependants, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  dependants: string;//Dependants\n\n  @PropertyPanelField({\n    inputType: 'toggle', label: 'Verification Mandatory?', conditionInputType: 'isOtpVerificationRequired', conditionInputData: ['true'],\n    helpText: 'Submit record without OTP verification', sortIndex: 3\n  })\n  @JsonProperty(Constants.submitWithoutVerification, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  submitWithoutVerification: string;\n\n  @JsonProperty(Constants.valueWithoutMask, ValueWithoutMaskConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n  valueWithoutMask: string = '';\n\n  @JsonProperty(Constants.markup, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  markup: string = '';\n\n  @PropertyPanelField({\n    inputType: 'text', label: 'Unit', conditionInputType: 'inputType', conditionInputData: ['numeric', 'decimal'],\n    helpText: 'Select unit'\n  })\n  @JsonProperty(Constants.unit, String, PropertyConvertingMode.IGNORE_NULLABLE)\n  unit: string = '';\n\n  @PropertyPanelField({ inputType: 'toggle', label: 'Multiple Selection',  conditionInputType:'inputType', conditionInputData:['text'],\n  helpText:'Allow selecting multiple choices or only one?' })\n  @JsonProperty(Constants.multiSelect, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE)\n  multiSelect: boolean = false;\n\n\n\n  constructor(field?: any) {\n    super(field);\n    if (field) {\n      this.textBox(field);\n    }\n    else {\n      this.newTextBox();\n    }\n  }\n  /**\n   * get widget value\n   *\n   * @returns\n   */\n  getWidgetValue(): any {\n    return this.value;\n  }\n\n  /**\n   * Set widget Value\n   *\n   * @param value\n   */\n  setWidgetValue(value: any): void {\n    this.value = value;\n  }\n\n  /**\n   * this will return serialize of widget\n   */\n  getWidgetSerializedValue(): string {\n\n    if (this.value) {\n      return this.value.toString();\n    }\n    else {\n      return '';\n    }\n  }\n\n  /**function to create text-box object with existing values\n  *\n  *@param field\n  *\n  */\n  textBox(field): void {\n    this.inputType = field[Constants.INPUT_TYPE];\n    this.minLength = field[Constants.MAX_LENGTH];\n    this.maxLength = field[Constants.MIN_LENGTH];\n    this.mask = field.mask;\n    this.isMultiline = field.isMultiline;\n    this.case = field.case;\n    this.defaultCase = field.defaultCase;\n    this.onValueEdit = field.onValueEdit;\n    this.choices = field.choices;\n\n    this.defaultText = field.defaultText;\n    this.otherMask = field.otherMask;\n    this.isOtpVerificationRequired = field.isOtpVerificationRequired;\n    this.validityDependents = field.validityDependents;\n    this.mastringType = field.mastringType;\n    this.maxDecimal = field.maxDecimal;\n    this.minNumber = field.minNumber;\n    this.allowMultipleEmails = field.allowMultipleEmails;\n    this.saveNumber = field.saveNumber;\n    this.maxNumber = field.maxNumber;\n    this.dependants = field.dependants;\n    this.submitWithoutVerification = field.submitWithoutVerification;\n    this.valueWithoutMask = field.valueWithoutMask;\n    this.unit = field.unit;\n    this.multiSelect=field.multiSelect;\n    this.name='TextBox';\n  }\n\n  // Function to create new text-box object\n  newTextBox(): void {\n    this.inputType = 'text';\n    this.minLength = null;\n    this.maxLength = 1000;\n    this.mask = 'none';\n    this.isMultiline = false;\n    this.case = null;\n    this.defaultCase = null;\n    this.onValueEdit = null;\n    this.choices = null;\n    this.defaultText = null;\n    this.otherMask = null;\n    this.isOtpVerificationRequired = false;\n    this.validityDependents = null;\n    this.mastringType = null;\n    this.maxDecimal = '2';\n    this.minNumber = '0';\n    this.allowMultipleEmails = false;\n    this.saveNumber = '1';\n    this.maxNumber = '999999';\n    this.dependants = null;\n    this.submitWithoutVerification = '1';\n    this.valueWithoutMask = '';\n    this.type = WidgetType.textBox;\n    this.identifier = 'textBox';\n    this.unit = null;\n    this.multiSelect=false;\n    this.name='TextBox';\n\n  }\n\n\n  // Method to retrieve UI metadata for a property\n  public static getPropertyPanelFieldMetadata(target: any, key: string): PropertyPanelFieldMetadata {\n    return Reflect.getMetadata(key, target);\n  }\n\n  // Method to retrieve UI metadata for all properties\n  public getPropertyPanelFieldUIProperties(): any {\n    const properties: { [key: string]: PropertyPanelFieldMetadata } = {};\n\n    const indexMap = new Map<string, number>();\n    // Get the list of property  names using Object.getOwnPropertyNames\n    const propertyNames = Object.getOwnPropertyNames(this);\n    const prop = []; // to hold sorted property names\n    const newProp = []; // to hold property names without sortIndex\n    // Loop through each property name and retrieve the UI metadata using getUIPrPropertyPanelFieldMetadata\n    for (const propertyName of propertyNames) {\n      const metadata = TextBox.getPropertyPanelFieldMetadata(this, propertyName);\n      if (metadata) {\n        properties[propertyName] = metadata;\n        if (metadata.sortIndex) {\n          prop.splice(metadata.sortIndex, 0, propertyName);\n        }\n        else {\n          newProp.push(propertyName);\n        }\n      }\n    }\n    const data = {\n      properties: properties,\n      keys: prop.concat(newProp)\n    };\n    return data;\n  }\n\n}\n"]}

package/esm2020/lib/forms/page/widgets/timestamp.mjs

@@ -0,0 +1,155 @@
+var TimeStamp_1;
+import { __decorate, __metadata } from "tslib";
+import { Constants } from '../common/constants';
+import { JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';
+import { Widget } from './widget';
+import { SetValueModeType } from '../common/widget-enums';
+import { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';
+import { PropertyPanelField } from '../common/property-panel-field';
+import { TimestampComponent } from '../../../sculptor-lib/widgets/timestamp/timestamp.component';
+let TimeStamp = TimeStamp_1 = class TimeStamp extends Widget {
+    /*
+    * Constructor
+    */
+    constructor(field) {
+        super(field);
+        this.component = TimestampComponent;
+        this.value = '';
+        this.widgetIcon = 'axo_timestamp';
+        this.dateFormat = '';
+        this.helpMessage = '';
+        this.mode = null;
+        this.displayDateFormat = '';
+        this.allowChanging = false;
+        this.markup = '';
+        if (field) {
+            this.timestamp(field);
+        }
+        else {
+            this.newTimestamp();
+        }
+    }
+    // Function to create new Toggle object
+    newTimestamp() {
+        this.markup = '';
+        this.mode = SetValueModeType.onTap;
+        this.allowChanging = null;
+        this.dateFormat = '';
+        this.helpMessage = null;
+        this.name = 'TimeStamp';
+    }
+    /**function to create Toggle object with existing values
+   *
+   *@param field
+   *
+   */
+    timestamp(field) {
+        this.markup = field.markup;
+        this.mode = field[Constants.mode];
+        this.allowChanging = field[Constants.isAllowChanging];
+        this.dateFormat = field[Constants.dateFormat];
+        this.helpMessage = field[Constants.helpMessage];
+        this.name = 'TimeStamp';
+    }
+    /**
+     * get widget value
+     *
+     * @returns
+     */
+    getWidgetValue() {
+        return this.value;
+    }
+    /**
+     * Set widget Value
+     *
+     * @param value
+     */
+    setWidgetValue(value) {
+        this.value = value;
+    }
+    /**
+     * this will return serialize of widget
+     */
+    getWidgetSerializedValue() {
+        if (this.value) {
+            return this.value.toString();
+        }
+        else {
+            return '';
+        }
+    }
+    // Method to retrieve UI metadata for a property
+    static getPropertyPanelFieldMetadata(target, key) {
+        return Reflect.getMetadata(key, target);
+    }
+    // Method to retrieve UI metadata for all properties
+    getPropertyPanelFieldUIProperties() {
+        const properties = {};
+        const excludedProperties = ['repopulateValue'];
+        // Get the list of property  names using Object.getOwnPropertyNames
+        const propertyNames = Object.getOwnPropertyNames(this);
+        let uiProperties = new Array(propertyNames.length); // to hold sorted property names
+        const commonProperties = []; // to hold property names without sortIndex
+        // Loop through each property name and retrieve the UI metadata using getUIPrPropertyPanelFieldMetadata
+        for (const propertyName of propertyNames) {
+            const metadata = TimeStamp_1.getPropertyPanelFieldMetadata(this, propertyName);
+            if (metadata && !excludedProperties.includes(propertyName)) {
+                properties[propertyName] = metadata;
+                if (metadata.sortIndex != null) {
+                    uiProperties.splice(metadata.sortIndex, 1, propertyName);
+                }
+                else {
+                    commonProperties.push(propertyName);
+                }
+            }
+        }
+        uiProperties = uiProperties.filter(a => a);
+        const data = {
+            properties: properties,
+            keys: uiProperties.concat(commonProperties)
+        };
+        return data;
+    }
+};
+__decorate([
+    JsonProperty(Constants.dateFormat, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TimeStamp.prototype, "dateFormat", void 0);
+__decorate([
+    JsonProperty(Constants.helpMessage, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TimeStamp.prototype, "helpMessage", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'select', label: 'Mode',
+        choices: [{ value: SetValueModeType.onOpen, text: 'On Open' }, { value: SetValueModeType.onTap, text: 'On Tap' }, { value: SetValueModeType.onSubmit, text: 'On Submit' }],
+        required: false, helpText: 'Mode', sortIndex: 1
+    }),
+    JsonProperty(Constants.mode, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TimeStamp.prototype, "mode", void 0);
+__decorate([
+    PropertyPanelField({ inputType: 'text', label: 'Date format', helpText: 'Set the Date format',
+        sortIndex: 3
+    }),
+    JsonProperty(Constants.displayDateFormat, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TimeStamp.prototype, "displayDateFormat", void 0);
+__decorate([
+    PropertyPanelField({
+        inputType: 'toggle', label: 'Allow changing?', conditionInputType: 'mode',
+        helpText: 'Allow changing?', conditionInputData: [SetValueModeType.onTap], sortIndex: 2
+    }),
+    JsonProperty(Constants.isAllowChanging, StringToBooleanValueConverter, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", Boolean)
+], TimeStamp.prototype, "allowChanging", void 0);
+__decorate([
+    JsonProperty(Constants.markup, String, PropertyConvertingMode.IGNORE_NULLABLE),
+    __metadata("design:type", String)
+], TimeStamp.prototype, "markup", void 0);
+TimeStamp = TimeStamp_1 = __decorate([
+    JsonObject('TimeStamp'),
+    __metadata("design:paramtypes", [TimeStamp])
+], TimeStamp);
+export { TimeStamp };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timestamp.js","sourceRoot":"","sources":["../../../../../../../src/ax-common-ui-lib/src/lib/forms/page/widgets/timestamp.ts"],"names":[],"mappings":"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","sourcesContent":["import { Type } from '@angular/core';\nimport { Constants } from '../common/constants';\nimport { JsonObject, JsonProperty, PropertyConvertingMode } from 'json2typescript';\nimport { Widget } from './widget';\nimport { SetValueModeType } from '../common/widget-enums';\nimport { StringToBooleanValueConverter } from '../value-converters/string-to-bool-value-converter';\nimport { PropertyPanelField, PropertyPanelFieldMetadata } from '../common/property-panel-field';\nimport { TimestampComponent } from '../../../sculptor-lib/widgets/timestamp/timestamp.component';\n\n@JsonObject('TimeStamp')\nexport class TimeStamp extends Widget{\n    component: Type<TimestampComponent> = TimestampComponent;\n\n    value:  string ='' ;\n    widgetIcon: string ='axo_timestamp';\n\n\n    @JsonProperty(Constants.dateFormat,String,PropertyConvertingMode.IGNORE_NULLABLE)\n    dateFormat: string='';\n\n    @JsonProperty(Constants.helpMessage,String,PropertyConvertingMode.IGNORE_NULLABLE)\n    helpMessage: string='';\n\n    @PropertyPanelField({\n        inputType: 'select', label: 'Mode',\n        choices: [ {value: SetValueModeType.onOpen, text: 'On Open'}, {value: SetValueModeType.onTap, text: 'On Tap'} ,{value: SetValueModeType.onSubmit, text: 'On Submit'}],\n        required: false, helpText: 'Mode' , sortIndex: 1\n      })\n    @JsonProperty(Constants.mode,String,PropertyConvertingMode.IGNORE_NULLABLE)\n    mode: SetValueModeType=null;\n\n    @PropertyPanelField({ inputType: 'text', label: 'Date format', helpText: 'Set the Date format',\n    sortIndex : 3  \n    })\n    @JsonProperty(Constants.displayDateFormat,String,PropertyConvertingMode.IGNORE_NULLABLE)\n    displayDateFormat: string='';\n\n    @PropertyPanelField({\n        inputType: 'toggle', label: 'Allow changing?', conditionInputType: 'mode',\n        helpText: 'Allow changing?' , conditionInputData:[SetValueModeType.onTap], sortIndex : 2\n      })\n    @JsonProperty(Constants.isAllowChanging ,StringToBooleanValueConverter,PropertyConvertingMode.IGNORE_NULLABLE)\n    allowChanging: boolean= false;\n\n    \n    @JsonProperty(Constants.markup, String, PropertyConvertingMode.IGNORE_NULLABLE)\n    markup: string = '';\n\n\n\n\n    /*\n    * Constructor\n    */\n    constructor(field?: TimeStamp){\n        super(field);\n        if(field){\n            this.timestamp(field);\n        }\n        else{\n            this.newTimestamp();\n        }\n    }\n\n    // Function to create new Toggle object\n    newTimestamp(): void{\n      this.markup = '';\n      this.mode = SetValueModeType.onTap;\n      this.allowChanging = null;\n      this.dateFormat='';\n      this.helpMessage = null;\n      this.name = 'TimeStamp';\n\n    }\n\n     /**function to create Toggle object with existing values\n    *\n    *@param field\n    *\n    */\n    timestamp(field): void{\n        this.markup = field.markup;\n        this.mode = field[Constants.mode];\n        this.allowChanging = field[Constants.isAllowChanging];\n        this.dateFormat=field[Constants.dateFormat];\n        this.helpMessage = field[Constants.helpMessage];\n        this.name = 'TimeStamp';\n\n\n    }\n    /**\n     * get widget value\n     *\n     * @returns\n     */\n    getWidgetValue(): any {\n        return this.value;\n    }\n\n    /**\n     * Set widget Value\n     *\n     * @param value\n     */\n    setWidgetValue(value: any) {\n        this.value = value;\n    }\n\n    /**\n     * this will return serialize of widget\n     */\n     getWidgetSerializedValue() {\n        if(this.value){\n            return this.value.toString();\n        }\n        else{\n            return '';\n        }\n    }\n\n  // Method to retrieve UI metadata for a property\n  public static getPropertyPanelFieldMetadata(target: any, key: string): PropertyPanelFieldMetadata {\n    return Reflect.getMetadata(key, target);\n  }\n\n  // Method to retrieve UI metadata for all properties\n  public getPropertyPanelFieldUIProperties(): any {\n    const properties: { [key: string]: PropertyPanelFieldMetadata } = {};\n    const excludedProperties=['repopulateValue'];\n    // Get the list of property  names using Object.getOwnPropertyNames\n    const propertyNames = Object.getOwnPropertyNames(this);\n    let uiProperties = new Array(propertyNames.length); // to hold sorted property names\n    const commonProperties = []; // to hold property names without sortIndex\n    // Loop through each property name and retrieve the UI metadata using getUIPrPropertyPanelFieldMetadata\n    for (const propertyName of propertyNames) {\n      const metadata = TimeStamp.getPropertyPanelFieldMetadata(this, propertyName);\n      if (metadata && !excludedProperties.includes(propertyName)) {\n        properties[propertyName] = metadata;\n        if (metadata.sortIndex != null) {\n          uiProperties.splice(metadata.sortIndex, 1, propertyName);\n        }\n        else {\n          commonProperties.push(propertyName);\n        }\n      }\n    }\n    uiProperties = uiProperties.filter(a => a);\n    const data = {\n      properties: properties,\n      keys: uiProperties.concat(commonProperties)\n    };\n    return data;\n  }\n\n}"]}