@onesy/ui-react 1.0.0

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@onesy/ui-react",
+  "version": "1.0.0",
+  "description": "UI for React",
+  "repository": "https://github.com/onesy-org/onesy.git",
+  "author": "Lazar <lazareric2@gmail.com>",
+  "license": "MIT",
+  "private": false,
+  "main": "./index.js",
+  "module": "./esm/index.js",
+  "types": "./index.d.ts",
+  "keywords": [
+    "ui",
+    "react",
+    "react-ui",
+    "user-interface",
+    "frontend",
+    "front-end",
+    "backend",
+    "back-end",
+    "web",
+    "browser",
+    "javascript",
+    "js",
+    "typescript",
+    "node",
+    "nodejs",
+    "library",
+    "onesy",
+    "utils"
+  ],
+  "peerDependencies": {
+    "@onesy/style-react": "^1.0.1",
+    "react": "^18.1.0",
+    "react-dom": "^18.2.0",
+    "react-router-dom": "^6.15.0"
+  },
+  "dependencies": {
+    "@onesy/date": "^1.0.0",
+    "@onesy/errors": "^1.0.0",
+    "@amaui/icons-material-rounded-react": "^1.0.4",
+    "@onesy/log": "^1.0.0",
+    "@onesy/subscription": "^1.0.0",
+    "@onesy/utils": "^1.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=12.0.0",
+    "yarn": ">=1.22"
+  }
+}

package/types.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="react" />
+import { IBreakpoint, TPaletteVersion } from '@onesy/style-react';
+export declare type IPoint = [number, number];
+export declare type ITonal = true | false | 'secondary';
+declare type RGB = `rgb(${number}, ${number}, ${number})`;
+declare type RGBA = `rgba(${number}, ${number}, ${number}, ${number})`;
+declare type HSL = `hsl(${number}, ${number}, ${number})`;
+declare type HSLA = `hsla(${number}, ${number}, ${number}, ${number})`;
+declare type HEX = `#${string}`;
+declare type Color = RGB | RGBA | HSL | HSLA | HEX;
+export declare type IColor = 'default' | 'themed' | 'inverted' | 'inherit' | TPaletteVersion | Color;
+export declare type IVersion = 'filled' | 'outlined' | 'outlined-without-background' | 'text';
+export declare type ISize = 'small' | 'regular' | 'large';
+export declare type ISizeAny = ISize | number;
+export declare type IElevation = 0 | 1 | 2 | 3 | 4 | 6 | 8 | 9 | 12 | 16 | 24;
+export declare type IElementReference = string | React.FC<any> | (React.ForwardRefExoticComponent<any>);
+export declare type IElement = React.ReactNode | React.ReactNode[] | React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export declare type IElementAny = IElement | string | number | boolean | null | undefined;
+export declare type IHTMLElement = Element | HTMLElement;
+export declare type IPropsAny = Record<string, any>;
+export declare type IStyle = React.CSSProperties | undefined;
+export declare type IChildren = React.ReactNode | React.ReactNode[];
+export declare type IRef = React.MutableRefObject<any>;
+export interface IBaseElement {
+    Component?: any;
+    className?: string;
+    style?: IStyle;
+    children?: IChildren;
+    [property: string]: any;
+}
+export declare type IMethodTransition = (element?: IHTMLElement) => any;
+export declare type IValueBreakpoints = IBreakpoint | 'default';
+export interface IMediaObject {
+    id?: string;
+    name?: string;
+    mime?: string;
+    url: string;
+    urlSmall?: string;
+    urlEmbed?: string;
+}
+export {};

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/useForm/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './useForm';
+export { default as useForm } from './useForm';
+export { default as validate } from './validate';

package/useForm/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = exports.useForm = exports.default = void 0;
+var useForm_1 = require("./useForm");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useForm_1).default; } });
+var useForm_2 = require("./useForm");
+Object.defineProperty(exports, "useForm", { enumerable: true, get: function () { return __importDefault(useForm_2).default; } });
+var validate_1 = require("./validate");
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return __importDefault(validate_1).default; } });

package/useForm/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "main": "./index.js",
+  "module": "../esm/useForm/index.js",
+  "types": "./index.d.ts"
+}

package/useForm/useForm.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import { IValidateVales } from './validate';
+export interface IUseForm {
+    values: IValidateVales;
+    validate?: (values: IValidateVales, form: any) => boolean;
+    rerenderOnUpdate?: boolean;
+    autoValidate?: boolean;
+    valueDefault?: any;
+    validDefault?: boolean;
+}
+export interface IUseFormOnChangeOptions {
+    rerenderOnUpdate?: boolean;
+}
+declare const useForm: (props: IUseForm) => {
+    value: any;
+    values: any;
+    valid: boolean;
+    init: () => void;
+    validate: () => Promise<boolean>;
+    onChange: (...args: [Array<[string, any, any?, IUseFormOnChangeOptions?]>] | [string, any, any?, IUseFormOnChangeOptions?]) => Promise<void>;
+    clear: () => void;
+    updateForm: React.Dispatch<React.SetStateAction<{
+        value: any;
+        values: any;
+        valid: boolean;
+    }>>;
+};
+export default useForm;

package/useForm/useForm.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const utils_1 = require("@onesy/utils");
+const validate_1 = __importDefault(require("./validate"));
+const useForm = (props) => {
+    const { values: values_ = {}, validate: validate_, rerenderOnUpdate = true, autoValidate, valueDefault, validDefault } = props;
+    const [form, setForm] = react_1.default.useState({
+        value: valueDefault !== undefined ? valueDefault : {},
+        values: (0, utils_1.copy)(values_ || {}),
+        valid: validDefault !== undefined ? validDefault : false
+    });
+    const refs = {
+        form: react_1.default.useRef(form),
+        value: react_1.default.useRef((0, utils_1.copy)(valueDefault !== undefined ? valueDefault : {})),
+        values: react_1.default.useRef((0, utils_1.copy)(values_ || {})),
+        valid: react_1.default.useRef(validDefault !== undefined ? validDefault : false)
+    };
+    refs.form.current = form;
+    const init = () => {
+        const formNew = Object.assign({}, refs.form.current);
+        const { values } = formNew;
+        const value = {};
+        const properties = Object.keys(values);
+        properties.forEach(item => {
+            const valueProperty = values[item];
+            if ((valueProperty === null || valueProperty === void 0 ? void 0 : valueProperty.value) !== undefined) {
+                (0, utils_1.setObjectValue)(value, item, (0, utils_1.copy)(valueProperty.value));
+            }
+        });
+        // update
+        refs.value.current = value;
+        setForm(previous => {
+            return Object.assign(Object.assign({}, previous), { value });
+        });
+    };
+    react_1.default.useEffect(() => {
+        // init
+        init();
+    }, []);
+    const onChange = async (...args) => {
+        var _a, _b;
+        const formNew = Object.assign({}, refs.form.current);
+        const value = {};
+        const valuesArgs = (0, utils_1.is)('array', args[0]) ? args[0] : [args];
+        const options = (valuesArgs[0][3] || {});
+        const rerenderOnUpdate_ = options.rerenderOnUpdate !== undefined ? options.rerenderOnUpdate : rerenderOnUpdate;
+        const values = refs.values.current;
+        for (const arg of valuesArgs) {
+            const [property_, value_, propertyNested] = arg;
+            let property = values[property_];
+            if (!property) {
+                values[property_] = {
+                    name: (_b = (_a = (propertyNested || property_)) === null || _a === void 0 ? void 0 : _a.split('.')) === null || _b === void 0 ? void 0 : _b.slice(-1)[0],
+                    touched: true
+                };
+                property = values[property_];
+            }
+            if (!propertyNested)
+                property.value = value_;
+            else
+                (0, utils_1.setObjectValue)(property.value, propertyNested, value_);
+            property.touched = true;
+            if (autoValidate) {
+                // Validate the property
+                if (property.required && property.value === undefined) {
+                    const name = (0, utils_1.is)('function', property.propertyNameUpdate) ? property.propertyNameUpdate(property.name) : property.capitalize !== false ? (0, utils_1.capitalize)(property.name) : property.name;
+                    property.error = `${name} is required`;
+                }
+                else {
+                    property.error = undefined;
+                    // validations
+                    try {
+                        await (0, validate_1.default)(property, property_, formNew);
+                    }
+                    catch (error) {
+                        property.error = error.message;
+                    }
+                }
+            }
+        }
+        const properties = Object.keys(values);
+        let valid = autoValidate ? properties.every((item) => {
+            const prop = values[item];
+            return (!prop.error &&
+                (!prop.required ||
+                    prop.value !== undefined));
+        }) : refs.valid.current;
+        if (autoValidate && (0, utils_1.is)('function', validate_))
+            valid = valid && validate_(values, formNew);
+        properties.forEach(item => {
+            const valueProperty = values[item];
+            if ((valueProperty === null || valueProperty === void 0 ? void 0 : valueProperty.value) !== undefined) {
+                (0, utils_1.setObjectValue)(value, item, (0, utils_1.copy)(valueProperty.value));
+            }
+        });
+        // update
+        refs.value.current = value;
+        refs.values.current = values;
+        refs.valid.current = valid;
+        if (rerenderOnUpdate_) {
+            setForm(previous => {
+                return Object.assign(Object.assign({}, previous), { value,
+                    values,
+                    valid });
+            });
+        }
+    };
+    const validate = async () => {
+        const formNew = Object.assign({}, refs.form.current);
+        const values = refs.values.current;
+        const value = {};
+        const properties = Object.keys(values);
+        for (const item of properties) {
+            const property = values[item];
+            // Validate the property
+            if (property.required && property.value === undefined) {
+                const name = (0, utils_1.is)('function', property.propertyNameUpdate) ? property.propertyNameUpdate(property.name) : property.capitalize !== false ? (0, utils_1.capitalize)(property.name) : property.name;
+                property.error = `${name} is required`;
+            }
+            else {
+                property.error = undefined;
+                // validations
+                try {
+                    await (0, validate_1.default)(property, item, formNew);
+                    property.error = undefined;
+                }
+                catch (error) {
+                    property.error = error.message;
+                }
+            }
+        }
+        let valid = properties.every((item) => {
+            const prop = values[item];
+            return (!prop.error &&
+                (!prop.required ||
+                    prop.value !== undefined));
+        });
+        if ((0, utils_1.is)('function', validate_))
+            valid = valid && validate_(values, formNew);
+        // value
+        properties.forEach(item => {
+            const valueProperty = values[item];
+            if ((valueProperty === null || valueProperty === void 0 ? void 0 : valueProperty.value) !== undefined) {
+                (0, utils_1.setObjectValue)(value, item, (0, utils_1.copy)(valueProperty.value));
+            }
+        });
+        // update
+        refs.value.current = value;
+        refs.values.current = values;
+        refs.valid.current = valid;
+        setForm(previous => {
+            return Object.assign(Object.assign({}, previous), { value,
+                values,
+                valid });
+        });
+        return valid;
+    };
+    const clear = () => {
+        const formNew = Object.assign(Object.assign({}, refs.form.current), { value: (0, utils_1.copy)(valueDefault !== undefined ? valueDefault : {}), values: (0, utils_1.copy)(values_ || {}), valid: validDefault !== undefined ? validDefault : false });
+        // update
+        refs.value.current = formNew.value;
+        refs.values.current = formNew.values;
+        refs.valid.current = formNew.valid;
+        setForm(previous => {
+            return Object.assign(Object.assign({}, previous), formNew);
+        });
+    };
+    return Object.assign(Object.assign({}, form), { value: rerenderOnUpdate ? form.value : refs.value.current, values: rerenderOnUpdate ? form.values : refs.values.current, valid: rerenderOnUpdate ? form.valid : refs.valid.current, init,
+        validate,
+        onChange,
+        clear, updateForm: setForm });
+};
+exports.default = useForm;

package/useForm/validate.d.ts

@@ -0,0 +1,65 @@
+import { TIsType, IOptions as IIsOptions } from '@onesy/utils/is';
+import { TIsValidType, IOptions as IIsValidOptions } from '@onesy/utils/isValid';
+export interface IValidateOptions {
+    message?: string;
+    uriDecode?: boolean;
+    parse?: boolean;
+}
+export interface IValidateModelValueIs {
+    type?: TIsType;
+    options?: IIsOptions;
+}
+export interface IValidateModelValueIsValid {
+    type?: TIsValidType;
+    options?: IIsValidOptions;
+}
+export interface IValidateModelValueMethodOptions {
+    form: IForm;
+    property: string;
+    object: IValidateModelValue;
+    options: IValidateOptions;
+}
+export declare type IValidateModelValueMethod = (value: any, options: IValidateModelValueMethodOptions) => Promise<any> | any;
+export declare type IValidateModelValueValidations = 'required' | 'is' | 'isValid' | 'of' | 'ofValid' | 'equal' | 'notEqual' | 'equalDeep' | 'notEqualDeep' | 'some' | 'in' | 'every' | 'properties' | 'notProperties' | 'min' | 'max' | 'length' | 'method';
+export declare type IValidateModelMessages = {
+    [p in IValidateModelValueValidations]?: string;
+};
+export interface IValidateModelValue {
+    name: string;
+    value?: any;
+    message?: string;
+    messages?: IValidateModelMessages;
+    required?: boolean;
+    is?: TIsType | TIsType[] | IValidateModelValueIs | IValidateModelValueIs[];
+    isValid?: TIsValidType | TIsValidType[] | IValidateModelValueIsValid | IValidateModelValueIsValid[];
+    of?: TIsType | TIsType[] | IValidateModelValueIs | IValidateModelValueIs[];
+    ofValid?: TIsValidType | TIsValidType[] | IValidateModelValueIsValid | IValidateModelValueIsValid[];
+    equal?: any;
+    notEqual?: any;
+    equalDeep?: any;
+    notEqualDeep?: any;
+    some?: any[];
+    in?: any[];
+    every?: any[];
+    properties?: string[];
+    notProperties?: string[];
+    min?: number;
+    max?: number;
+    length?: number;
+    method?: IValidateModelValueMethod | IValidateModelValueMethod[];
+    touched?: boolean;
+    error?: string;
+    capitalize?: boolean;
+    propertyNameUpdate?: (value: any) => string;
+}
+export declare type IUseFormValues = Record<string, IValidateModelValue>;
+export interface IForm {
+    value: any;
+    values: IUseFormValues;
+    valid: boolean;
+}
+export declare type IValidateValidation = (property: IValidateModelValue, form: IForm) => void | Error | Promise<void | Error>;
+export declare type IValidateVales = Record<string, IValidateModelValue>;
+export declare const onValidateError: (options: IValidateOptions, model: IValidateModelValue, message?: any) => never;
+declare const validate: (model: IValidateModelValue, property: string, form: IForm, options_?: IValidateOptions) => Promise<void>;
+export default validate;

package/useForm/validate.js

@@ -0,0 +1,219 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onValidateError = void 0;
+const is_1 = __importDefault(require("@onesy/utils/is"));
+const isValid_1 = __importDefault(require("@onesy/utils/isValid"));
+const utils_1 = require("@onesy/utils");
+const errors_1 = require("@onesy/errors");
+const onValidateError = (options, model, message) => {
+    const error = new errors_1.ValidationError(message);
+    // Entire model message
+    if (options.message !== undefined)
+        error.message = options.message;
+    // model item message
+    else if (model.message !== undefined)
+        error.message = model.message;
+    // error
+    throw error;
+};
+exports.onValidateError = onValidateError;
+const validate = async (model, property, form, options_) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+    const options = (0, utils_1.merge)((options_ && (0, is_1.default)('object', options_)) ? options_ : {}, { uriDecode: true, parse: true });
+    const name = (0, is_1.default)('function', model.propertyNameUpdate) ? model.propertyNameUpdate(model.name) : model.capitalize !== false ? (0, utils_1.capitalize)(model.name) : model.name;
+    const value = model.value;
+    // value validate
+    // with options above
+    // required
+    if (model.required) {
+        const response = value;
+        if (response === undefined)
+            (0, exports.onValidateError)(options, model, ((_a = model.messages) === null || _a === void 0 ? void 0 : _a.required) || `${name} is required`);
+    }
+    // only validate
+    // if value is not undefined
+    // as it is optional
+    if (value === undefined)
+        return;
+    // is
+    if (model.is !== undefined) {
+        const is_ = ((0, is_1.default)('array', model.is) ? model.is : [model.is]).filter(Boolean);
+        for (const item of is_) {
+            const itemType = (item === null || item === void 0 ? void 0 : item.type) || item;
+            const itemOptions = (item === null || item === void 0 ? void 0 : item.options) || undefined;
+            const response = (0, is_1.default)(itemType, value, itemOptions);
+            if (!response)
+                (0, exports.onValidateError)(options, model, ((_b = model.messages) === null || _b === void 0 ? void 0 : _b.is) || `${name} has to be a valid ${(0, utils_1.cleanValue)(itemType)}`);
+        }
+    }
+    // is valid
+    if (model.isValid !== undefined) {
+        const isValid_ = ((0, is_1.default)('array', model.isValid) ? model.isValid : [model.isValid]).filter(Boolean);
+        for (const item of isValid_) {
+            const itemType = (item === null || item === void 0 ? void 0 : item.type) || item;
+            const itemOptions = (item === null || item === void 0 ? void 0 : item.options) || undefined;
+            const response = (0, isValid_1.default)(itemType, value, itemOptions);
+            if (!response)
+                (0, exports.onValidateError)(options, model, ((_c = model.messages) === null || _c === void 0 ? void 0 : _c.isValid) || `${name} has to be a valid ${(0, utils_1.cleanValue)(itemType)}`);
+        }
+    }
+    // of
+    if (model.of !== undefined) {
+        const of_ = ((0, is_1.default)('array', model.of) ? model.of : [model.of]).filter(Boolean);
+        if ((0, is_1.default)('array', value)) {
+            const response = value.every(valueItem => {
+                return of_.some(item => {
+                    const itemType = (item === null || item === void 0 ? void 0 : item.type) || item;
+                    const itemOptions = (item === null || item === void 0 ? void 0 : item.options) || undefined;
+                    return (0, is_1.default)(itemType, valueItem, itemOptions);
+                });
+            });
+            if (!response)
+                (0, exports.onValidateError)(options, model, ((_d = model.messages) === null || _d === void 0 ? void 0 : _d.of) || `${name} items have to be one of ${of_.map(item => (item === null || item === void 0 ? void 0 : item.type) || item).join(', ')}`);
+        }
+    }
+    // ofValid
+    if (model.ofValid !== undefined) {
+        const ofValid = ((0, is_1.default)('array', model.ofValid) ? model.ofValid : [model.ofValid]).filter(Boolean);
+        if ((0, is_1.default)('array', value)) {
+            const response = value.every(valueItem => {
+                return ofValid.some(item => {
+                    const itemType = (item === null || item === void 0 ? void 0 : item.type) || item;
+                    const itemOptions = (item === null || item === void 0 ? void 0 : item.options) || undefined;
+                    return (0, isValid_1.default)(itemType, valueItem, itemOptions);
+                });
+            });
+            if (!response)
+                (0, exports.onValidateError)(options, model, ((_e = model.messages) === null || _e === void 0 ? void 0 : _e.ofValid) || `${name} items have to be one of valid ${ofValid.map(item => (item === null || item === void 0 ? void 0 : item.type) || item).join(', ')}`);
+        }
+    }
+    // equal
+    if (model.equal !== undefined) {
+        const response = value === model.equal;
+        if (!response)
+            (0, exports.onValidateError)(options, model, ((_f = model.messages) === null || _f === void 0 ? void 0 : _f.equal) || `${name} has to be equal to ${(0, utils_1.stringify)(model.equal)}`);
+    }
+    // not equal
+    if (model.notEqual !== undefined) {
+        const response = value !== model.equal;
+        if (!response)
+            (0, exports.onValidateError)(options, model, ((_g = model.messages) === null || _g === void 0 ? void 0 : _g.notEqual) || `${name} has to not be equal to ${(0, utils_1.stringify)(model.equal)}`);
+    }
+    // equal deep
+    if (model.equalDeep !== undefined) {
+        const response = (0, utils_1.equalDeep)(value, model.equalDeep);
+        if (!response)
+            (0, exports.onValidateError)(options, model, ((_h = model.messages) === null || _h === void 0 ? void 0 : _h.equalDeep) || `${name} has to be equal to ${(0, utils_1.stringify)(model.equalDeep)}`);
+    }
+    // not equal deep
+    if (model.notEqualDeep !== undefined) {
+        const response = !(0, utils_1.equalDeep)(value, model.notEqualDeep);
+        if (!response)
+            (0, exports.onValidateError)(options, model, ((_j = model.messages) === null || _j === void 0 ? void 0 : _j.notEqualDeep) || `${name} has to not be equal to ${(0, utils_1.stringify)(model.notEqualDeep)}`);
+    }
+    // some
+    if ((0, is_1.default)('array', model.some)) {
+        let response;
+        if ((0, is_1.default)('string', value)) {
+            response = !!model.some.find(item => (0, utils_1.equalDeep)(value, item));
+            if (!response)
+                (0, exports.onValidateError)(options, model, ((_k = model.messages) === null || _k === void 0 ? void 0 : _k.some) || `${name} has to be one of ${model.some.map(item => (0, utils_1.stringify)(item)).join(', ')}`);
+        }
+        else if ((0, is_1.default)('array', value)) {
+            response = value.some(item => !!model.some.find(item_ => (0, utils_1.equalDeep)(item, item_)));
+            if (!response)
+                (0, exports.onValidateError)(options, model, ((_l = model.messages) === null || _l === void 0 ? void 0 : _l.some) || `${name} has to include some of ${model.some.map(item => (0, utils_1.stringify)(item)).join(', ')}`);
+        }
+    }
+    // in
+    // every
+    const every = model.in || model.every;
+    if ((0, is_1.default)('array', every)) {
+        let response;
+        if ((0, is_1.default)('string', value)) {
+            response = !!every.find(item => (0, utils_1.equalDeep)(value, item));
+            if (!response)
+                (0, exports.onValidateError)(options, model, ((_m = model.messages) === null || _m === void 0 ? void 0 : _m.in) || ((_o = model.messages) === null || _o === void 0 ? void 0 : _o.every) || `${name} has to be one of ${every.map(item => (0, utils_1.stringify)(item)).join(', ')}`);
+        }
+        else if ((0, is_1.default)('array', value)) {
+            response = value.every(item => !!every.find(item_ => (0, utils_1.equalDeep)(item, item_)));
+            if (!response)
+                (0, exports.onValidateError)(options, model, ((_p = model.messages) === null || _p === void 0 ? void 0 : _p.in) || ((_q = model.messages) === null || _q === void 0 ? void 0 : _q.every) || `${name} has to include one of ${every.map(item => (0, utils_1.stringify)(item)).join(', ')}`);
+        }
+    }
+    // properties
+    if ((0, is_1.default)('array', model.properties)) {
+        const allowed = model.properties;
+        const keys = Object.keys(value);
+        const response = keys.every(item => allowed.includes(item));
+        if (!response)
+            (0, exports.onValidateError)(options, model, ((_r = model.messages) === null || _r === void 0 ? void 0 : _r.properties) || `${name} allowed properties are ${allowed.join(', ')}`);
+    }
+    // not properties
+    if ((0, is_1.default)('array', model.notProperties)) {
+        const notAllowed = model.notProperties;
+        const keys = Object.keys(value);
+        const response = keys.every(item => !notAllowed.includes(item));
+        if (!response)
+            (0, exports.onValidateError)(options, model, ((_s = model.messages) === null || _s === void 0 ? void 0 : _s.notProperties) || `${name} includes not allowed property. Not allowed properties are ${notAllowed.join(', ')}`);
+    }
+    // min
+    // max
+    // length
+    if (![undefined, null].includes(value) &&
+        ((0, is_1.default)('number', model.min) ||
+            (0, is_1.default)('number', model.max) ||
+            (0, is_1.default)('number', model.length))) {
+        let length = value;
+        // object
+        if ((0, is_1.default)('object', value))
+            length = Object.keys(value).length;
+        // number
+        else if ((0, is_1.default)('number', value))
+            length = value;
+        // string, array, map, etc.
+        else {
+            length = (value === null || value === void 0 ? void 0 : value.length) !== undefined ? value === null || value === void 0 ? void 0 : value.length : value === null || value === void 0 ? void 0 : value.size;
+        }
+        if ((0, is_1.default)('number', model.min)) {
+            const response = length >= model.min;
+            if (!response)
+                (0, exports.onValidateError)(options, model, ((_t = model.messages) === null || _t === void 0 ? void 0 : _t.min) || `${name} has to be minimum ${model.min}`);
+        }
+        if ((0, is_1.default)('number', model.max)) {
+            const response = length <= model.max;
+            if (!response)
+                (0, exports.onValidateError)(options, model, ((_u = model.messages) === null || _u === void 0 ? void 0 : _u.max) || `${name} can be maximum ${model.max}`);
+        }
+        if ((0, is_1.default)('number', model.length)) {
+            const response = length === model.length;
+            if (!response)
+                (0, exports.onValidateError)(options, model, ((_v = model.messages) === null || _v === void 0 ? void 0 : _v.length) || `${name} has to be exactly ${model.length} in length/size`);
+        }
+    }
+    // method
+    const methods = ((0, is_1.default)('array', model.method) ? model.method : [model.method]).filter(Boolean);
+    for (const method_ of methods) {
+        try {
+            // either throw error or Promise.reject or return false
+            const response = await method_(value, {
+                form,
+                object: model,
+                property,
+                options
+            });
+            if (response !== undefined) {
+                if (!response)
+                    throw new errors_1.ValidationError(`${name} is invalid`);
+            }
+        }
+        catch (error) {
+            const messageValue = (error === null || error === void 0 ? void 0 : error.message) !== undefined ? error.message : error;
+            (0, exports.onValidateError)(options, model, ((_w = model.messages) === null || _w === void 0 ? void 0 : _w.method) || messageValue);
+        }
+    }
+};
+exports.default = validate;

package/useLocation/index.d.ts

@@ -0,0 +1 @@
+export { default } from './useLocation';

package/useLocation/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var useLocation_1 = require("./useLocation");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(useLocation_1).default; } });

package/useLocation/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "main": "./index.js",
+  "module": "../esm/useLocation/index.js",
+  "types": "./index.d.ts"
+}

package/useLocation/useLocation.d.ts

@@ -0,0 +1,7 @@
+export interface IUseLocation {
+}
+declare const useLocation: {
+    (props?: IUseLocation): Location;
+    displayName: string;
+};
+export default useLocation;