@carefrees/form-utils-vue-hooks 0.0.13

package/esm/instance/ruleIntsnace.js

@@ -0,0 +1,52 @@
+import async_validator from "async-validator";
+import { ref, toValue } from "vue";
+class RuleInstanceBase {
+    sort;
+    instance;
+    name = '';
+    rules = ref([]);
+    messages = ref([]);
+    isRequired = ()=>{
+        const findItem = (toValue(this.rules) || []).find((item)=>item?.required);
+        return !!findItem;
+    };
+    isValidate = ()=>{
+        const rules = toValue(this.rules);
+        return Array.isArray(rules) && rules.length;
+    };
+    updatedMessages = (messages)=>{
+        this.messages.value = messages;
+    };
+    updatedRules = (rules)=>{
+        this.rules.value = rules;
+        this.updatedMessages?.([]);
+    };
+    validate = ()=>new Promise((resolve, reject)=>{
+            const rules = toValue(this.rules);
+            const form = toValue(this.instance);
+            const value = form?.getFieldValue?.(this.name);
+            new async_validator({
+                [this.name]: rules || []
+            }).validate({
+                [this.name]: value
+            }).then((values)=>{
+                this.updatedMessages([]);
+                resolve(values);
+            }).catch(({ errors })=>{
+                if (Array.isArray(errors)) {
+                    this.updatedMessages(errors);
+                    reject(errors);
+                } else reject();
+            });
+        });
+    getValidateResult = ()=>{
+        const msg = toValue(this.messages);
+        const tip = Array.isArray(msg) ? msg.map((it)=>it.message) : '';
+        const isInvalid = Array.isArray(tip) ? !!tip.length : !!tip;
+        return {
+            tip,
+            isInvalid
+        };
+    };
+}
+export { RuleInstanceBase };

package/esm/interface/index.d.ts

@@ -0,0 +1,31 @@
+import { ComputedRef, Ref } from 'vue';
+export interface MessageType {
+    /**信息*/
+    message?: string;
+    [s: string]: unknown;
+}
+export interface ErrorDataField {
+    /**字段*/
+    name: string;
+    /**排序*/
+    sort?: string;
+    /**错误信息*/
+    errors: MessageType[];
+}
+export interface ValidateErrorEntity<Values = any> {
+    values: Values;
+    /**错误信息*/
+    errorFields: ErrorDataField[];
+}
+export interface Callbacks<Values = any> {
+    /**值更新触发*/
+    onValuesChange?: (changedValues: any, values: Values) => void;
+    /**提交保存 验证成功*/
+    onFinish?: (values: Values) => void;
+    /**提交保存 验证失败*/
+    onFinishFailed?: (errorInfo: ValidateErrorEntity<Values>) => void;
+}
+export type ComputedRefBase<T> = ComputedRef<T> | Ref<T>;
+export type PartialComputedRefs<T> = {
+    [K in keyof T]: ComputedRefBase<T[K]>;
+};

package/esm/utils/cloneByNamePathList.d.ts

@@ -0,0 +1,3 @@
+import { PropertyName } from './interface';
+/**获取路径数据*/
+export declare function cloneByNamePathList(store: Record<string, any>, namePathList: PropertyName[]): Record<string, any>;

package/esm/utils/cloneByNamePathList.js

@@ -0,0 +1,11 @@
+import { get } from "./get.js";
+import { set } from "./set.js";
+function cloneByNamePathList(store, namePathList) {
+    let newStore = {};
+    namePathList.forEach((namePath)=>{
+        const value = get(store, namePath);
+        newStore = set(newStore, namePath, value);
+    });
+    return newStore;
+}
+export { cloneByNamePathList };

package/esm/utils/get.d.ts

@@ -0,0 +1,26 @@
+import { PropertyPath } from './interface';
+/**
+ * Gets the value at `path` of `object`. If the resolved value is
+ * `undefined`, the `defaultValue` is returned in its place.
+ *
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @see has, hasIn, set, unset
+ * @example
+ *
+ * const object = { 'a': [{ 'b': { 'c': 3 } }] }
+ *
+ * get(object, 'a[0].b.c')
+ * // => 3
+ *
+ * get(object, ['a', '0', 'b', 'c'])
+ * // => 3
+ *
+ * get(object, 'a.b.c', 'default')
+ * // => 'default'
+ */
+export declare const get: (object: Object, path: PropertyPath, defaultValue?: any) => any;

package/esm/utils/get.js

@@ -0,0 +1,13 @@
+import { castPath, toKey } from "./utils.js";
+function baseGet(object, path) {
+    path = castPath(path, object);
+    let index = 0;
+    const length = path.length;
+    while(null != object && index < length)object = object[toKey(path[index++])];
+    return index && index === length ? object : void 0;
+}
+const get = (object, path, defaultValue)=>{
+    const result = null == object ? void 0 : baseGet(object, path);
+    return void 0 === result ? defaultValue : result;
+};
+export { get };

package/esm/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './get';
+export * from './set';
+export * from './utils';
+export * from './cloneByNamePathList';

package/esm/utils/index.js

@@ -0,0 +1,4 @@
+export * from "./get.js";
+export * from "./set.js";
+export * from "./utils.js";
+export * from "./cloneByNamePathList.js";

package/esm/utils/interface.d.ts

@@ -0,0 +1,3 @@
+export type Many<T> = T | readonly T[];
+export type PropertyName = string | number | symbol | undefined;
+export type PropertyPath = Many<PropertyName>;

package/esm/utils/set.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @description [从lodash中搬了部分需要的代码块](https://www.lodashjs.com/)
+ */
+import { PropertyPath } from './interface';
+/**
+ * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
+ * it's created. Arrays are created for missing index properties while objects
+ * are created for all other missing properties. Use `setWith` to customize
+ * `path` creation.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns `object`.
+ * @see has, hasIn, get, unset
+ * @example
+ *
+ * const object = { 'a': [{ 'b': { 'c': 3 } }] }
+ *
+ * set(object, 'a[0].b.c', 4)
+ * console.log(object.a[0].b.c)
+ * // => 4
+ *
+ * set(object, ['x', '0', 'y', 'z'], 5)
+ * console.log(object.x[0].y.z)
+ * // => 5
+ */
+export declare function set<T = any>(object: T, path: PropertyPath, value: any): T;

package/esm/utils/set.js

@@ -0,0 +1,29 @@
+import { assignValue, castPath, isIndex, isObject, toKey } from "./utils.js";
+function baseSet(object, path, value, customizer) {
+    if (!isObject(object)) return object;
+    path = castPath(path, object);
+    const length = path.length;
+    const lastIndex = length - 1;
+    let index = -1;
+    let nested = object;
+    while(null != nested && ++index < length){
+        const key = toKey(path[index]);
+        let newValue = value;
+        if (index !== lastIndex) {
+            const objValue = nested[key];
+            newValue = customizer ? customizer(objValue, key, nested) : void 0;
+            if (void 0 === newValue) newValue = Array.isArray(objValue) ? [
+                ...objValue
+            ] : null !== objValue && '[object Object]' === Object.prototype.toString.call(objValue) ? {
+                ...objValue
+            } : isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
+        }
+        assignValue(nested, key, newValue);
+        nested = nested[key];
+    }
+    return object;
+}
+function set(object, path, value) {
+    return null == object ? object : baseSet(object, path, value);
+}
+export { set };

package/esm/utils/utils.d.ts

@@ -0,0 +1,172 @@
+/**
+ * @description [从lodash中搬了部分需要的代码块](https://www.lodashjs.com/)
+ */
+import { PropertyPath } from './interface';
+/**
+ * Converts `string` to a property path array.
+ *
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the property path array.
+ */
+export declare const stringToPath: (string: string) => string[];
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+export declare function getTag(value: any): string;
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * isSymbol(Symbol.iterator)
+ * // => true
+ *
+ * isSymbol('abc')
+ * // => false
+ */
+export declare function isSymbol(value: any): boolean;
+/**
+ * Checks if `value` is a property name and not a property path.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ */
+export declare function isKey(value: any, object: any): boolean;
+/**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {Array} Returns the cast property path array.
+ */
+export declare function castPath(value: any, object: any): any[];
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+export declare function toKey(value: any): any;
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * isObject({})
+ * // => true
+ *
+ * isObject([1, 2, 3])
+ * // => true
+ *
+ * isObject(Function)
+ * // => true
+ *
+ * isObject(null)
+ * // => false
+ */
+export declare function isObject(value: any): boolean;
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+export declare function isIndex(value: any, length?: number): boolean;
+/**
+ * The base implementation of `assignValue` and `assignMergeValue` without
+ * value checks.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+export declare function baseAssignValue(object: any, key: any, value: any): void;
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * const object = { 'a': 1 }
+ * const other = { 'a': 1 }
+ *
+ * eq(object, object)
+ * // => true
+ *
+ * eq(object, other)
+ * // => false
+ *
+ * eq('a', 'a')
+ * // => true
+ *
+ * eq('a', Object('a'))
+ * // => false
+ *
+ * eq(NaN, NaN)
+ * // => true
+ */
+export declare function eq(value: any, other: any): boolean;
+/**
+ * Assigns `value` to `key` of `object` if the existing value is not equivalent.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+export declare function assignValue(object: any, key: any, value: any): void;
+/**
+ * Checks if `path` is a direct property of `object`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = { 'a': { 'b': 2 } };
+ * var other = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.has(object, 'a');
+ * // => true
+ *
+ * _.has(object, 'a.b');
+ * // => true
+ *
+ * _.has(object, ['a', 'b']);
+ * // => true
+ *
+ * _.has(other, 'a');
+ * // => false
+ */
+export declare function has<T = any>(object: T, path: PropertyPath): boolean;

package/esm/utils/utils.js

@@ -0,0 +1,131 @@
+const charCodeOfDot = '.'.charCodeAt(0);
+const reEscapeChar = /\\(\\)?/g;
+const rePropName = RegExp("[^.[\\]]+|\\[(?:([^\"'][^[]*)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))", 'g');
+const stringToPath = (string)=>{
+    const result = [];
+    if (string.charCodeAt(0) === charCodeOfDot) result.push('');
+    string.replace(rePropName, (match, expression, quote, subString)=>{
+        let key = match;
+        if (quote) key = subString.replace(reEscapeChar, '$1');
+        else if (expression) key = expression.trim();
+        result.push(key);
+    });
+    return result;
+};
+function getTag(value) {
+    const toString = Object.prototype.toString;
+    if (null == value) return void 0 === value ? '[object Undefined]' : '[object Null]';
+    return toString.call(value);
+}
+function isSymbol(value) {
+    const type = typeof value;
+    return 'symbol' === type || 'object' === type && null != value && '[object Symbol]' === getTag(value);
+}
+const reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+const reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+    if (Array.isArray(value)) return false;
+    const type = typeof value;
+    if ('number' === type || 'boolean' === type || null == value || isSymbol(value)) return true;
+    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || null != object && value in Object(object);
+}
+function castPath(value, object) {
+    if (Array.isArray(value)) return value;
+    return isKey(value, object) ? [
+        value
+    ] : stringToPath(value);
+}
+const INFINITY = 1 / 0;
+function toKey(value) {
+    if ('string' == typeof value || isSymbol(value)) return value;
+    const result = `${value}`;
+    return '0' === result && 1 / value === -INFINITY ? '-0' : result;
+}
+function isObject(value) {
+    const type = typeof value;
+    return null != value && ('object' === type || 'function' === type);
+}
+const MAX_SAFE_INTEGER = 9007199254740991;
+const reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+    const type = typeof value;
+    length = null == length ? MAX_SAFE_INTEGER : length;
+    return !!length && ('number' === type || 'symbol' !== type && reIsUint.test(value)) && value > -1 && value % 1 === 0 && value < length;
+}
+function baseAssignValue(object, key, value) {
+    if ('__proto__' === key) Object.defineProperty(object, key, {
+        configurable: true,
+        enumerable: true,
+        value: value,
+        writable: true
+    });
+    else object[key] = value;
+}
+function eq(value, other) {
+    return value === other || value !== value && other !== other;
+}
+const utils_hasOwnProperty = Object.prototype.hasOwnProperty;
+function assignValue(object, key, value) {
+    const objValue = object[key];
+    if (utils_hasOwnProperty.call(object, key) && eq(objValue, value)) {
+        if (void 0 === value && !(key in object)) baseAssignValue(object, key, value);
+    } else if (0 !== value || 1 / value === 1 / objValue) baseAssignValue(object, key, value);
+}
+function baseHas(object, key) {
+    return null != object && utils_hasOwnProperty.call(object, key);
+}
+function isLength(value) {
+    return 'number' == typeof value && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+function isObjectLike(value) {
+    return null != value && 'object' == typeof value;
+}
+var objectProto = Object.prototype;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+function getRawTag(value) {
+    var isOwn = utils_hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+    try {
+        value[symToStringTag] = void 0;
+        var unmasked = true;
+    } catch (e) {}
+    var result = nativeObjectToString.call(value);
+    if (unmasked) if (isOwn) value[symToStringTag] = tag;
+    else delete value[symToStringTag];
+    return result;
+}
+var nativeObjectToString = objectProto.toString;
+function objectToString(value) {
+    return nativeObjectToString.call(value);
+}
+var nullTag = '[object Null]', undefinedTag = '[object Undefined]';
+function baseGetTag(value) {
+    if (null == value) return void 0 === value ? undefinedTag : nullTag;
+    return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+var argsTag = '[object Arguments]';
+function baseIsArguments(value) {
+    return isObjectLike(value) && baseGetTag(value) == argsTag;
+}
+const propertyIsEnumerable = objectProto.propertyIsEnumerable;
+var isArguments = baseIsArguments(function() {
+    return arguments;
+}()) ? baseIsArguments : function(value) {
+    return isObjectLike(value) && utils_hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
+};
+function hasPath(object, path, hasFunc) {
+    path = castPath(path, object);
+    var index = -1, length = path.length, result = false;
+    while(++index < length){
+        var key = toKey(path[index]);
+        if (!(result = null != object && hasFunc(object, key))) break;
+        object = object[key];
+    }
+    if (result || ++index != length) return result;
+    length = null == object ? 0 : object.length;
+    return !!length && isLength(length) && isIndex(key, length) && (Array.isArray(object) || isArguments(object));
+}
+function has(object, path) {
+    return null != object && hasPath(object, path, baseHas);
+}
+export { assignValue, baseAssignValue, castPath, eq, getTag, has, isIndex, isKey, isObject, isSymbol, stringToPath, toKey };

package/lib/hooks/attr/attr.FormItem.d.ts

@@ -0,0 +1,94 @@
+import { FormInstanceBase } from '../../instance/formInstance';
+import { FormItemInstanceBase } from '../../instance/formItemInstance';
+import { RegisterFormItemOptions } from './../register/register.FormItem';
+import { Ref } from 'vue';
+import type { RuleInstanceBase } from '../../instance/ruleIntsnace';
+export interface FormItemAttrOptions extends RegisterFormItemOptions {
+    /**依赖更新项*/
+    dependencies?: string[];
+    /**通知 只用于校验规则提示 字段 */
+    noticeOnlyRuleDataField?: string[];
+    /**是否保护值(不进行表单项组件卸载重置初始值)*/
+    preserve?: boolean;
+    /**重写规则*/
+    useRules?: (ruleInstance: Ref<RuleInstanceBase>, form: Ref<FormInstanceBase>, formItemInstance: Ref<FormItemInstanceBase>) => void;
+    /**输入框属性重写*/
+    useAttrs?: (attrs: any, form: Ref<FormInstanceBase>, formItemInstance: Ref<FormItemInstanceBase>) => any;
+    /**输入框属性*/
+    inputAttrs?: Object;
+    /**传递组件字段*/
+    valuePropName?: string;
+    /**取值字段(默认和valuePropName值相同)*/
+    getValuePath?: string;
+    /**自定义获取值*/
+    getValueFromEvent?: (event: any, form: Ref<FormInstanceBase>, formItemInstance: Ref<FormItemInstanceBase>) => any;
+    /**值格式化*/
+    formatValue?: (value: any, form: Ref<FormInstanceBase>, formItemInstance: Ref<FormItemInstanceBase>, event: any) => any;
+    /**触发数据更新之后触发（用于数据联动之类的）*/
+    onAfterUpdate?: (value: any, form: Ref<FormInstanceBase>, formItemInstance: Ref<FormItemInstanceBase>, event: any) => void;
+    /**事件名称*/
+    trigger?: string;
+}
+/**表单项参数*/
+export declare const useFormItemAttr: (options: FormItemAttrOptions) => {
+    valuePropName: string;
+    htmlFor: import("vue").ComputedRef<string>;
+    onChange: (event: any) => void;
+    formItemInstance: Ref<FormItemInstanceBase, FormItemInstanceBase>;
+    form: Ref<FormInstanceBase<any>, FormInstanceBase<any>>;
+    ruleInstance: Ref<RuleInstanceBase, RuleInstanceBase>;
+    newAttrs: import("vue").ComputedRef<{
+        name: string;
+        id: string;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    }>;
+    attrsLastData: Ref<{
+        name: string;
+        id: string;
+        constructor: Function;
+        toString: () => string;
+        toLocaleString: () => string;
+        valueOf: () => Object;
+        hasOwnProperty: (v: PropertyKey) => boolean;
+        isPrototypeOf: (v: Object) => boolean;
+        propertyIsEnumerable: (v: PropertyKey) => boolean;
+    }, {
+        name: string;
+        id: string;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: PropertyKey): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: PropertyKey): boolean;
+    } | {
+        name: string;
+        id: string;
+        constructor: Function;
+        toString: () => string;
+        toLocaleString: () => string;
+        valueOf: () => Object;
+        hasOwnProperty: (v: PropertyKey) => boolean;
+        isPrototypeOf: (v: Object) => boolean;
+        propertyIsEnumerable: (v: PropertyKey) => boolean;
+    }>;
+    validateResult: Ref<{
+        tip: string | (string | undefined)[];
+        isInvalid: boolean;
+    }, {
+        tip: string | (string | undefined)[];
+        isInvalid: boolean;
+    } | {
+        tip: string | (string | undefined)[];
+        isInvalid: boolean;
+    }>;
+    newSort: import("vue").ComputedRef<string>;
+    newName: import("vue").ComputedRef<string>;
+};