@gravity-ui/dynamic-forms 1.0.0 → 1.0.1

package/build/esm/lib/kit/utils/common.d.ts

@@ -0,0 +1,6 @@
+import { ValidationErrors } from 'final-form';
+import { FormValue, Spec, StringSpec } from '../../core';
+export declare const getChildError: (name: string, errors?: ValidationErrors, head?: boolean) => boolean;
+export declare const isNotEmptyValue: (value: FormValue | undefined, spec: Spec | undefined) => boolean;
+export declare const prepareSpec: <Type extends Spec>(spec: Type, parseJsonDefaultValue?: boolean) => Type;
+export declare const isCorrectSizeParams: (spec: StringSpec) => boolean;

package/build/esm/lib/kit/utils/common.js

@@ -0,0 +1,143 @@
+import { ARRAY_ERROR } from 'final-form';
+import _ from 'lodash';
+import { isArraySpec, isObjectSpec, isStringSpec, } from '../../core';
+import { isFloat } from '../validators/helpers';
+import { divide } from './bigIntMath';
+export const getChildError = (name, errors, head) => {
+    const error = _.get(errors, name);
+    if (!head && (error === null || error === void 0 ? void 0 : error[ARRAY_ERROR])) {
+        return true;
+    }
+    else if (_.isArray(error)) {
+        return error.some((itemError, idx) => {
+            if (_.isArray(itemError) || _.isObjectLike(itemError)) {
+                return getChildError(`${name}[${idx}]`, errors);
+            }
+            return Boolean(itemError);
+        });
+    }
+    else if (_.isObjectLike(error)) {
+        return Object.keys(error).some((key) => {
+            if (_.isArray(error[key]) || _.isObjectLike(error[key])) {
+                return getChildError(`${name}.${key}`, errors);
+            }
+            return Boolean(error[key]);
+        });
+    }
+    return false;
+};
+export const isNotEmptyValue = (value, spec) => {
+    var _a;
+    if (_.isNil(value)) {
+        return false;
+    }
+    if (_.isString(value)) {
+        if (!value) {
+            return false;
+        }
+        if (isStringSpec(spec) && ((_a = spec.viewSpec.hideValues) === null || _a === void 0 ? void 0 : _a.includes(value))) {
+            return false;
+        }
+    }
+    if (_.isObject(value) && isObjectSpec(spec)) {
+        const keys = Object.keys(value);
+        // the only case when an empty object is considered a non-empty value is when it is a stub for oneof
+        if (!keys.filter((key) => { var _a; return isNotEmptyValue(value[key], (_a = spec.properties) === null || _a === void 0 ? void 0 : _a[key]); }).length &&
+            spec.viewSpec.type !== 'oneof') {
+            return false;
+        }
+    }
+    if (_.isArray(value) &&
+        isArraySpec(spec) &&
+        !value.filter((item) => isNotEmptyValue(item, spec.items)).length) {
+        return false;
+    }
+    return true;
+};
+export const prepareSpec = (spec, parseJsonDefaultValue) => {
+    var _a, _b, _c;
+    if (_.isObjectLike(spec)) {
+        const result = _.cloneDeep(spec);
+        if (_.isString(result.type)) {
+            result.type = result.type.toLowerCase();
+        }
+        if (!_.isNil(result.defaultValue)) {
+            let _defaultValue = result.defaultValue;
+            if (parseJsonDefaultValue) {
+                try {
+                    _defaultValue = JSON.parse(result.defaultValue);
+                }
+                catch (_d) {
+                    _defaultValue = undefined;
+                }
+            }
+            if (typeof _defaultValue === result.type) {
+                result.defaultValue = _defaultValue;
+            }
+            else {
+                result.defaultValue = undefined;
+            }
+        }
+        if (_.isString((_a = result.viewSpec) === null || _a === void 0 ? void 0 : _a.type)) {
+            result.viewSpec.type = result.viewSpec.type.toLowerCase();
+        }
+        if (_.isString((_b = result.viewSpec) === null || _b === void 0 ? void 0 : _b.layout)) {
+            result.viewSpec.layout = result.viewSpec.layout.toLowerCase();
+        }
+        if (_.isString((_c = result.viewSpec) === null || _c === void 0 ? void 0 : _c.themeLabel)) {
+            result.viewSpec.themeLabel = result.viewSpec.themeLabel.toLowerCase();
+        }
+        if (_.isString(result.validator)) {
+            result.validator = result.validator.toLowerCase();
+        }
+        if (result.maxLength === '0' &&
+            result.minLength === '0') {
+            result.maxLength = undefined;
+            result.minLength = undefined;
+        }
+        else {
+            if (!_.isNil(result.maxLength) && isFloat(`${result.maxLength}`)) {
+                result.maxLength = BigInt(result.maxLength);
+            }
+            if (!_.isNil(result.minLength) && isFloat(`${result.minLength}`)) {
+                result.minLength = BigInt(result.minLength);
+            }
+        }
+        if (result.items) {
+            result.items = prepareSpec(result.items, parseJsonDefaultValue);
+        }
+        if (result.maximum === 0 && result.minimum === 0) {
+            result.maximum = undefined;
+            result.minimum = undefined;
+        }
+        else {
+            if (!_.isNil(result.maximum) && isFloat(`${result.maximum}`)) {
+                result.maximum = Number(result.maximum);
+            }
+            if (!_.isNil(result.minimum) && isFloat(`${result.minimum}`)) {
+                result.minimum = Number(result.minimum);
+            }
+        }
+        if (_.isString(result.format)) {
+            result.format = result.format.toLowerCase();
+        }
+        if (_.isObjectLike(result.properties)) {
+            Object.keys(result.properties).forEach((key) => {
+                result.properties[key] = prepareSpec(result.properties[key], parseJsonDefaultValue);
+            });
+        }
+        return result;
+    }
+    return spec;
+};
+export const isCorrectSizeParams = (spec) => {
+    const { sizeParams } = spec.viewSpec;
+    if (!sizeParams ||
+        !_.isString(sizeParams.defaultType) ||
+        !_.isObject(sizeParams.scale) ||
+        !sizeParams.scale[sizeParams.defaultType] ||
+        Object.values(sizeParams.scale).some(({ factor }) => !divide(factor, factor))) {
+        return false;
+    }
+    return true;
+};

package/build/esm/lib/kit/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './cn';
+export * from './common';
+export * from './bigIntMath';

package/build/esm/lib/kit/utils/index.js

@@ -0,0 +1,3 @@
+export * from './cn';
+export * from './common';
+export * from './bigIntMath';

package/build/esm/lib/kit/validators/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const isInt: (value: string) => boolean;
+export declare const isFloat: (value: string) => boolean;

package/build/esm/lib/kit/validators/helpers.js

@@ -0,0 +1,8 @@
+export const isInt = (value) => {
+    const regex = /^(?:[-+]?(?:0|[1-9]\d*))$/;
+    return regex.test(value);
+};
+export const isFloat = (value) => {
+    const regex = /^(?:[-+]?(?:\d+))?(?:\.\d*)?(?:[eE][+-]?(?:\d+))?$/;
+    return regex.test(value);
+};

package/build/esm/lib/kit/validators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './messages';
+export * from './validators';

package/build/esm/lib/kit/validators/index.js

@@ -0,0 +1,2 @@
+export * from './messages';
+export * from './validators';

package/build/esm/lib/kit/validators/messages.d.ts

@@ -0,0 +1,16 @@
+export declare let ErrorMessages: {
+    REQUIRED: string;
+    INVALID: string;
+    INT: string;
+    NUMBER: string;
+    minLength(count: number | bigint): string;
+    minLengthArr(count: number | bigint): string;
+    maxLength(count: number | bigint): string;
+    maxLengthArr(count: number | bigint): string;
+    minNumber(count: number | bigint): string;
+    maxNumber(count: number | bigint): string;
+    SPACE_START: string;
+    SPACE_END: string;
+    DOT_END: string;
+    ZERO_START: string;
+};

package/build/esm/lib/kit/validators/messages.js

@@ -0,0 +1,34 @@
+import i18n from '../i18n';
+import { subscribeConfigure } from '../i18n/configure';
+const getErrorMessages = () => ({
+    REQUIRED: i18n('label_error-required'),
+    INVALID: i18n('label_error-invalid'),
+    INT: i18n('label_error-int'),
+    NUMBER: i18n('label_error-number'),
+    minLength(count) {
+        return i18n('label_error-min-length', { count });
+    },
+    minLengthArr(count) {
+        return i18n('label_error-min-length-array', { count });
+    },
+    maxLength(count) {
+        return i18n('label_error-max-length', { count });
+    },
+    maxLengthArr(count) {
+        return i18n('label_error-max-length-array', { count });
+    },
+    minNumber(count) {
+        return i18n('label_error-min-number', { count });
+    },
+    maxNumber(count) {
+        return i18n('label_error-max-number', { count });
+    },
+    SPACE_START: i18n('label_error-space-start'),
+    SPACE_END: i18n('label_error-space-end'),
+    DOT_END: i18n('label_error-dot-end'),
+    ZERO_START: i18n('label_error-zero-start'),
+});
+export let ErrorMessages = getErrorMessages();
+subscribeConfigure(() => {
+    ErrorMessages = getErrorMessages();
+});

package/build/esm/lib/kit/validators/validators.d.ts

@@ -0,0 +1,34 @@
+import { ArraySpec, ArrayValue, BooleanSpec, NumberSpec, ObjectSpec, ObjectValue, StringSpec } from '../../core';
+export interface GetArrayValidatorParams {
+    ignoreRequiredCheck?: boolean;
+    ignoreMaxLengthCheck?: boolean;
+    ignoreMinLengthCheck?: boolean;
+}
+export declare const getArrayValidator: (params?: GetArrayValidatorParams) => (spec: ArraySpec, value?: ArrayValue) => string | false;
+export interface GetBooleanValidatorParams {
+    ignoreRequiredCheck?: boolean;
+}
+export declare const getBooleanValidator: (params?: GetBooleanValidatorParams) => (spec: BooleanSpec, value?: boolean) => string | false;
+export interface GetNumberValidatorParams {
+    ignoreRequiredCheck?: boolean;
+    ignoreSpaceStartCheck?: boolean;
+    ignoreSpaceEndCheck?: boolean;
+    ignoreNumberCheck?: boolean;
+    ignoreMaximumCheck?: boolean;
+    ignoreMinimumCheck?: boolean;
+    ignoreIntCheck?: boolean;
+}
+export declare const getNumberValidator: (params?: GetNumberValidatorParams) => (spec: NumberSpec, value?: string | number) => string | false;
+export interface GetObjectValidatorParams {
+    ignoreRequiredCheck?: boolean;
+}
+export declare const getObjectValidator: (params?: GetObjectValidatorParams) => (spec: ObjectSpec, value?: ObjectValue) => string | false;
+export interface GetStringValidatorParams {
+    ignoreRequiredCheck?: boolean;
+    ignoreSpaceStartCheck?: boolean;
+    ignoreSpaceEndCheck?: boolean;
+    ignoreMaxLengthCheck?: boolean;
+    ignoreMinLengthCheck?: boolean;
+    ignoreRegExpCheck?: boolean;
+}
+export declare const getStringValidator: (params?: GetStringValidatorParams) => (spec: StringSpec, value?: string) => string | false;

package/build/esm/lib/kit/validators/validators.js

@@ -0,0 +1,124 @@
+import _ from 'lodash';
+import { ErrorMessages } from '../validators';
+import { isFloat, isInt } from './helpers';
+export const getArrayValidator = (params = {}) => {
+    const { ignoreRequiredCheck, ignoreMaxLengthCheck, ignoreMinLengthCheck } = params;
+    return (spec, value) => {
+        const valueLength = (value === null || value === void 0 ? void 0 : value.length) || 0;
+        if (!ignoreRequiredCheck && spec.required && !_.isArray(value)) {
+            return ErrorMessages.REQUIRED;
+        }
+        if (!ignoreMaxLengthCheck &&
+            typeof spec.maxLength === 'bigint' &&
+            valueLength > spec.maxLength) {
+            return ErrorMessages.maxLengthArr(spec.maxLength);
+        }
+        if (!ignoreMinLengthCheck &&
+            typeof spec.minLength === 'bigint' &&
+            valueLength < spec.minLength) {
+            return ErrorMessages.minLengthArr(spec.minLength);
+        }
+        return false;
+    };
+};
+export const getBooleanValidator = (params = {}) => {
+    const { ignoreRequiredCheck } = params;
+    return (spec, value) => {
+        if (!ignoreRequiredCheck && spec.required && !value) {
+            return ErrorMessages.REQUIRED;
+        }
+        return false;
+    };
+};
+export const getNumberValidator = (params = {}) => {
+    const { ignoreRequiredCheck, ignoreSpaceStartCheck, ignoreSpaceEndCheck, ignoreNumberCheck, ignoreMaximumCheck, ignoreMinimumCheck, ignoreIntCheck, } = params;
+    return (spec, value = '') => {
+        const stringValue = String(value);
+        if (!ignoreRequiredCheck && spec.required && !stringValue.length) {
+            return ErrorMessages.REQUIRED;
+        }
+        if (stringValue.length) {
+            if (!ignoreSpaceStartCheck && !stringValue[0].trim()) {
+                return ErrorMessages.SPACE_START;
+            }
+            if (!ignoreSpaceEndCheck && !stringValue[stringValue.length - 1].trim()) {
+                return ErrorMessages.SPACE_END;
+            }
+            if (stringValue[stringValue.length - 1] === '.') {
+                return ErrorMessages.DOT_END;
+            }
+            if (!ignoreNumberCheck && !isFloat(stringValue)) {
+                return ErrorMessages.NUMBER;
+            }
+            if ((stringValue.length > 1 && stringValue[0] === '0' && stringValue[1] !== '.') ||
+                (stringValue.length > 2 &&
+                    stringValue.substring(0, 2) === '-0' &&
+                    stringValue[2] !== '.')) {
+                return ErrorMessages.ZERO_START;
+            }
+        }
+        if (!ignoreMaximumCheck &&
+            _.isNumber(spec.maximum) &&
+            stringValue.length &&
+            Number(stringValue) > spec.maximum) {
+            return ErrorMessages.maxNumber(spec.maximum);
+        }
+        if (!ignoreMinimumCheck &&
+            _.isNumber(spec.minimum) &&
+            stringValue.length &&
+            spec.minimum > Number(stringValue)) {
+            return ErrorMessages.minNumber(spec.minimum);
+        }
+        if (_.isString(spec.format) && stringValue.length) {
+            if (!ignoreIntCheck && spec.format === 'int64' && !isInt(stringValue)) {
+                return ErrorMessages.INT;
+            }
+        }
+        return false;
+    };
+};
+export const getObjectValidator = (params = {}) => {
+    const { ignoreRequiredCheck } = params;
+    return (spec, value) => {
+        if (!ignoreRequiredCheck && spec.required && !value) {
+            return ErrorMessages.REQUIRED;
+        }
+        return false;
+    };
+};
+export const getStringValidator = (params = {}) => {
+    const { ignoreRequiredCheck, ignoreSpaceStartCheck, ignoreSpaceEndCheck, ignoreMaxLengthCheck, ignoreMinLengthCheck, ignoreRegExpCheck, } = params;
+    return (spec, value = '') => {
+        const valueLength = value === null || value === void 0 ? void 0 : value.length;
+        if (!ignoreRequiredCheck && spec.required && !valueLength) {
+            return ErrorMessages.REQUIRED;
+        }
+        if (valueLength) {
+            if (!ignoreSpaceStartCheck && !value[0].trim()) {
+                return ErrorMessages.SPACE_START;
+            }
+            if (!ignoreSpaceEndCheck && !value[value.length - 1].trim()) {
+                return ErrorMessages.SPACE_END;
+            }
+        }
+        if (!ignoreMaxLengthCheck &&
+            typeof spec.maxLength === 'bigint' &&
+            valueLength > spec.maxLength) {
+            return ErrorMessages.maxLength(spec.maxLength);
+        }
+        if (!ignoreMinLengthCheck &&
+            typeof spec.minLength === 'bigint' &&
+            valueLength < spec.minLength) {
+            return ErrorMessages.minLength(spec.minLength);
+        }
+        if (_.isString(spec.pattern) && spec.pattern.length) {
+            const regex = new RegExp(spec.pattern);
+            if (!ignoreRegExpCheck && !regex.test(value)) {
+                return _.isString(spec.patternError) && spec.patternError.length
+                    ? spec.patternError
+                    : ErrorMessages.INVALID;
+            }
+        }
+        return false;
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/dynamic-forms",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
   "license": "MIT",
   "main": "build/cjs/index.js",
@@ -32,7 +32,8 @@
     "build": "gulp",
     "build-storybook": "build-storybook",
     "dev": "start-storybook -p 6006",
-    "start": "start-storybook"
+    "start": "start-storybook",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {},
   "devDependencies": {