native-document 1.0.70 → 1.0.72

package/src/components/fom-control/field/types/RadioField.js

@@ -0,0 +1,44 @@
+import Field from "../Field";
+
+export default function RadioField(name, options, defaultConfig) {
+    Field.call(this, name, 'radio', defaultConfig);
+
+    Object.assign(this.$description, {
+        options: options || [],
+        layout: 'vertical'
+    });
+}
+
+RadioField.prototype = Object.create(Field.prototype);
+RadioField.prototype.constructor = RadioField;
+
+RadioField.prototype.options = function(opts) {
+    this.$description.options = opts;
+    return this;
+};
+
+RadioField.prototype.layout = function(value) {
+    const allowedLayouts = ['vertical', 'horizontal', 'grid'];
+
+    if (!allowedLayouts.includes(value)) {
+        throw new Error(`Invalid layout "${value}". Must be one of: ${allowedLayouts.join(', ')}`);
+    }
+
+    this.$description.layout = value;
+    return this;
+};
+
+RadioField.prototype.horizontal = function() {
+    this.$description.layout = 'horizontal';
+    return this;
+};
+
+RadioField.prototype.vertical = function() {
+    this.$description.layout = 'vertical';
+    return this;
+};
+
+RadioField.prototype.grid = function() {
+    this.$description.layout = 'grid';
+    return this;
+};

package/src/components/fom-control/field/types/RangeField.js

@@ -0,0 +1,17 @@
+import NumberField from "./NumberField";
+
+export default function RangeField(name, defaultConfig) {
+    NumberField.call(this, name, 'range', defaultConfig);
+
+    Object.assign(this.$description, {
+        showValue: true
+    });
+}
+
+RangeField.prototype = Object.create(NumberField.prototype);
+RangeField.prototype.constructor = RangeField;
+
+RangeField.prototype.showValue = function(enabled = true) {
+    this.$description.showValue = enabled;
+    return this;
+};

package/src/components/fom-control/field/types/SearchField.js

@@ -0,0 +1,17 @@
+import StringField from "./StringField";
+
+export default function SearchField(name, defaultConfig) {
+    StringField.call(this, name, 'search', defaultConfig);
+
+    Object.assign(this.$description, {
+        debounce: 300
+    });
+}
+
+SearchField.prototype = Object.create(StringField.prototype);
+SearchField.prototype.constructor = SearchField;
+
+SearchField.prototype.debounce = function(ms) {
+    this.$description.debounce = ms;
+    return this;
+};

package/src/components/fom-control/field/types/SelectField.js

@@ -0,0 +1,41 @@
+import Field from "../Field";
+
+export default function SelectField(name, options, defaultConfig) {
+    Field.call(this, name, 'select', defaultConfig);
+
+    Object.assign(this.$description, {
+        options: options || [],
+        multiple: false,
+        searchable: false,
+        clearable: false,
+        groups: null
+    });
+}
+
+SelectField.prototype = Object.create(Field.prototype);
+SelectField.prototype.constructor = SelectField;
+
+SelectField.prototype.options = function(opts) {
+    this.$description.options = opts;
+    return this;
+};
+
+SelectField.prototype.multiple = function(enabled = true) {
+    this.$description.multiple = enabled;
+    return this;
+};
+
+SelectField.prototype.searchable = function(enabled = true) {
+    this.$description.searchable = enabled;
+    return this;
+};
+
+SelectField.prototype.clearable = function(enabled = true) {
+    this.$description.clearable = enabled;
+    return this;
+};
+
+SelectField.prototype.groups = function(groupsConfig) {
+    this.$description.groups = groupsConfig;
+    return this;
+};

package/src/components/fom-control/field/types/StringField.js

@@ -0,0 +1,49 @@
+import Field from "../Field";
+import {Validation} from "../../validation/Validation";
+
+export default function StringField(name, type = 'text', defaultConfig = {}) {
+    Field.call(this, name, type, defaultConfig);
+}
+
+StringField.prototype = Object.create(Field.prototype);
+StringField.prototype.constructor = StringField;
+
+StringField.prototype.minLength = function(min, message) {
+    return this.addRule(Validation.minLength, [min], message);
+};
+
+StringField.prototype.maxLength = function(max, message) {
+    return this.addRule(Validation.maxLength, [max], message);
+};
+
+StringField.prototype.length = function(length, message) {
+    return this.addRule(Validation.length, [length], message);
+};
+
+StringField.prototype.pattern = function(regex, message) {
+    return this.addRule(Validation.pattern, [regex], message);
+};
+
+StringField.prototype.alphaOnly = function(message) {
+    return this.addRule(Validation.alphaOnly, [], message);
+};
+
+StringField.prototype.numericOnly = function(message) {
+    return this.addRule(Validation.numericOnly, [], message);
+};
+
+StringField.prototype.alphaNumeric = function(message) {
+    return this.addRule(Validation.alphaNumeric, [], message);
+};
+
+StringField.prototype.noSpaces = function(message) {
+    return this.addRule(Validation.noSpaces, [], message);
+};
+
+StringField.prototype.lowercase = function(message) {
+    return this.addRule(Validation.lowercase, [], message);
+};
+
+StringField.prototype.uppercase = function(message) {
+    return this.addRule(Validation.uppercase, [], message);
+};

package/src/components/fom-control/field/types/TelField.js

@@ -0,0 +1,38 @@
+// TelField.js
+import StringField from "./StringField";
+import {Validation} from "../../validation/Validation";
+
+export default function TelField(name, defaultConfig) {
+    StringField.call(this, name, 'tel', defaultConfig);
+
+    Object.assign(this.$description, {
+        countryCode: false,
+        mask: null
+    });
+}
+
+TelField.prototype = Object.create(StringField.prototype);
+TelField.prototype.constructor = TelField;
+
+TelField.prototype.phone = function(message) {
+    return this.addRule(Validation.phone, [], message);
+};
+
+TelField.prototype.countryCode = function(enabled = true) {
+    this.$description.countryCode = enabled;
+    return this;
+};
+
+TelField.prototype.mask = function(pattern) {
+    this.$description.mask = pattern;
+
+    const regex = pattern
+        .replace(/[().\-\s+]/g, '\\$&')
+        .replace(/#/g, '\\d');
+
+    this.addRule(Validation.pattern, [new RegExp(`^${regex}$`)],
+        `Invalid phone format. Expected: ${pattern}`
+    );
+
+    return this;
+};

package/src/components/fom-control/field/types/TextAreaField.js

@@ -0,0 +1,56 @@
+import StringField from "./StringField";
+
+export default function TextAreaField(name, defaultConfig) {
+    StringField.call(this, name, 'textarea', defaultConfig);
+
+    Object.assign(this.$description, {
+        ...this.$description,
+        rows: 4,
+        cols: null,
+        resize: 'vertical',
+        autoGrow: false,
+        characterCounter: false,
+    });
+}
+
+TextAreaField.prototype = Object.create(StringField.prototype);
+TextAreaField.prototype.constructor = TextAreaField;
+
+TextAreaField.prototype.rows = function(value) {
+    this.$description.rows = value;
+    return this;
+};
+
+TextAreaField.prototype.cols = function(value) {
+    this.$description.cols = value;
+    return this;
+};
+
+TextAreaField.prototype.resize = function(value) {
+    this.$description.resize = value;
+    return this;
+};
+
+TextAreaField.prototype.autoGrow = function(enabled = true) {
+    this.$description.autoGrow = enabled;
+    return this;
+};
+
+TextAreaField.prototype.characterCounter = function(enabled = true) {
+    this.$description.characterCounter = enabled;
+    return this;
+};
+
+TextAreaField.prototype.wordCount = function(min, max, message) {
+    this.$description.rules.push({
+        validate: (value) => {
+            if (!value) return true;
+            const words = value.trim().split(/\s+/).length;
+            if (min && words < min) return false;
+            if (max && words > max) return false;
+            return true;
+        },
+        message: message || `Word count must be between ${min || 0} and ${max || '∞'}`
+    });
+    return this;
+};

package/src/components/fom-control/field/types/TimeField.js

@@ -0,0 +1,45 @@
+// TimeField.js
+import Field from "../Field";
+import {Validation} from "../../validation/Validation";
+
+export default function TimeField(name, defaultConfig) {
+    Field.call(this, name, 'time', defaultConfig);
+
+    Object.assign(this.$description, {
+        format: 'HH:mm',
+        step: null
+    });
+}
+
+TimeField.prototype = Object.create(Field.prototype);
+TimeField.prototype.constructor = TimeField;
+
+TimeField.prototype.format = function(formatString) {
+    this.$description.format = formatString;
+    return this;
+};
+
+TimeField.prototype.step = function(seconds) {
+    this.$description.step = seconds;
+    return this;
+};
+
+TimeField.prototype.min = function(time, message) {
+    return this.addRule(Validation.afterTime, [time], message);
+};
+
+TimeField.prototype.max = function(time, message) {
+    return this.addRule(Validation.beforeTime, [time], message);
+};
+
+TimeField.prototype.between = function(startTime, endTime, message) {
+    return this.addRule(Validation.betweenTimes, [startTime, endTime], message);
+};
+
+TimeField.prototype.after = function(time, message) {
+    return this.addRule(Validation.afterTime, [time], message);
+};
+
+TimeField.prototype.before = function(time, message) {
+    return this.addRule(Validation.beforeTime, [time], message);
+};

package/src/components/fom-control/field/types/UrlField.js

@@ -0,0 +1,53 @@
+// UrlField.js
+import StringField from "./StringField";
+import {Validation} from "../../validation/Validation";
+
+export default function UrlField(name, defaultConfig) {
+    StringField.call(this, name, 'url', defaultConfig);
+
+    // Auto-apply url validation
+    this.addRule(Validation.url, []);
+}
+
+UrlField.prototype = Object.create(StringField.prototype);
+UrlField.prototype.constructor = UrlField;
+
+UrlField.prototype.url = function(message) {
+    const existingRule = this.$description.rules.find(r => r.fn === Validation.url);
+    if (existingRule && message) {
+        existingRule.message = message;
+    }
+    return this;
+};
+
+UrlField.prototype.protocol = function(allowedProtocols, message) {
+    this.$description.rules.push({
+        validate: (value) => {
+            if (!value) return true;
+            try {
+                const url = new URL(value);
+                return allowedProtocols.includes(url.protocol.replace(':', ''));
+            } catch {
+                return false;
+            }
+        },
+        message: message || `Allowed protocols: ${allowedProtocols.join(', ')}`
+    });
+    return this;
+};
+
+UrlField.prototype.domain = function(allowedDomains, message) {
+    this.$description.rules.push({
+        validate: (value) => {
+            if (!value) return true;
+            try {
+                const url = new URL(value);
+                return allowedDomains.includes(url.hostname);
+            } catch {
+                return false;
+            }
+        },
+        message: message || `Allowed domains: ${allowedDomains.join(', ')}`
+    });
+    return this;
+};

package/src/components/fom-control/index.js

@@ -0,0 +1,8 @@
+import Field from "./field/Field";
+import FormControl from "./FormControl";
+import './field/FieldFactory';
+
+export {
+    Field,
+    FormControl,
+}

package/src/components/fom-control/utils.js

@@ -0,0 +1,17 @@
+
+export function resolveParams(rule, values) {
+    return rule.params ?rule.params.map(param => {
+        if (typeof param === 'string') {
+            if(values.$parent && param.startsWith('@')) {
+                const paramName = param.substring(1);
+                if(values.$parent[paramName] !== undefined) {
+                    return values.$parent[paramName];
+                }
+            }
+            if(values[param] !== undefined) {
+                return values[param];
+            }
+        }
+        return param;
+    }): [];
+}