cnhis-design-vue 3.1.15-beta.4 → 3.1.15-beta.7

package/es/node_modules/@formily/path/esm/destructor.js

@@ -1,124 +0,0 @@
-import { isObjectPattern, isIdentifier, isArrayPattern, isDestructorExpression } from './types.js';
-import { isNum } from './shared.js';
-
-var DestructorCache = new Map();
-var isValid = function (val) { return val !== undefined && val !== null; };
-var getDestructor = function (source) {
-    return DestructorCache.get(source);
-};
-var setDestructor = function (source, rules) {
-    DestructorCache.set(source, rules);
-};
-var parseDestructorRules = function (node) {
-    var rules = [];
-    if (isObjectPattern(node)) {
-        var index_1 = 0;
-        node.properties.forEach(function (child) {
-            rules[index_1] = {
-                path: [],
-            };
-            rules[index_1].key = child.key.value;
-            rules[index_1].path.push(child.key.value);
-            if (isIdentifier(child.value)) {
-                rules[index_1].key = child.value.value;
-            }
-            var basePath = rules[index_1].path;
-            var childRules = parseDestructorRules(child.value);
-            var k = index_1;
-            childRules.forEach(function (rule) {
-                if (rules[k]) {
-                    rules[k].key = rule.key;
-                    rules[k].path = basePath.concat(rule.path);
-                }
-                else {
-                    rules[k] = {
-                        key: rule.key,
-                        path: basePath.concat(rule.path),
-                    };
-                }
-                k++;
-            });
-            if (k > index_1) {
-                index_1 = k;
-            }
-            else {
-                index_1++;
-            }
-        });
-        return rules;
-    }
-    else if (isArrayPattern(node)) {
-        var index_2 = 0;
-        node.elements.forEach(function (child, key) {
-            rules[index_2] = {
-                path: [],
-            };
-            rules[index_2].key = key;
-            rules[index_2].path.push(key);
-            if (isIdentifier(child)) {
-                rules[index_2].key = child.value;
-            }
-            var basePath = rules[index_2].path;
-            var childRules = parseDestructorRules(child);
-            var k = index_2;
-            childRules.forEach(function (rule) {
-                if (rules[k]) {
-                    rules[k].key = rule.key;
-                    rules[k].path = basePath.concat(rule.path);
-                }
-                else {
-                    rules[k] = {
-                        key: rule.key,
-                        path: basePath.concat(rule.path),
-                    };
-                }
-                k++;
-            });
-            if (k > index_2) {
-                index_2 = k;
-            }
-            else {
-                index_2++;
-            }
-        });
-        return rules;
-    }
-    if (isDestructorExpression(node)) {
-        return parseDestructorRules(node.value);
-    }
-    return rules;
-};
-var setInByDestructor = function (source, rules, value, mutators) {
-    rules.forEach(function (_a) {
-        var key = _a.key, path = _a.path;
-        mutators.setIn([key], source, mutators.getIn(path, value));
-    });
-};
-var getInByDestructor = function (source, rules, mutators) {
-    var response = {};
-    if (rules.length) {
-        if (isNum(rules[0].path[0])) {
-            response = [];
-        }
-    }
-    source = isValid(source) ? source : {};
-    rules.forEach(function (_a) {
-        var key = _a.key, path = _a.path;
-        mutators.setIn(path, response, source[key]);
-    });
-    return response;
-};
-var deleteInByDestructor = function (source, rules, mutators) {
-    rules.forEach(function (_a) {
-        var key = _a.key;
-        mutators.deleteIn([key], source);
-    });
-};
-var existInByDestructor = function (source, rules, start, mutators) {
-    return rules.every(function (_a) {
-        var key = _a.key;
-        return mutators.existIn([key], source, start);
-    });
-};
-
-export { deleteInByDestructor, existInByDestructor, getDestructor, getInByDestructor, parseDestructorRules, setDestructor, setInByDestructor };

package/es/node_modules/@formily/path/esm/index.js

@@ -1,579 +0,0 @@
-import { Parser } from './parser.js';
-import { isStr, isArr, isRegExp, isFn, isEqual, isNum, isObj } from './shared.js';
-import { getDestructor, getInByDestructor, setInByDestructor, deleteInByDestructor, existInByDestructor } from './destructor.js';
-import { Matcher } from './matcher.js';
-
-var __read = (undefined && undefined.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var pathCache = new Map();
-var isMatcher = Symbol('PATH_MATCHER');
-var isValid = function (val) { return val !== undefined && val !== null; };
-var isSimplePath = function (val) {
-    return val.indexOf('*') === -1 &&
-        val.indexOf('~') === -1 &&
-        val.indexOf('[') === -1 &&
-        val.indexOf(']') === -1 &&
-        val.indexOf(',') === -1 &&
-        val.indexOf(':') === -1 &&
-        val.indexOf(' ') === -1 &&
-        val[0] !== '.';
-};
-var isAssignable = function (val) {
-    return typeof val === 'object' || typeof val === 'function';
-};
-var isNumberIndex = function (val) {
-    return isStr(val) ? /^\d+$/.test(val) : isNum(val);
-};
-var getIn = function (segments, source) {
-    for (var i = 0; i < segments.length; i++) {
-        var index = segments[i];
-        var rules = getDestructor(index);
-        if (!rules) {
-            if (!isValid(source)) {
-                if (i !== segments.length - 1) {
-                    return source;
-                }
-                break;
-            }
-            source = source[index];
-        }
-        else {
-            source = getInByDestructor(source, rules, { setIn: setIn, getIn: getIn });
-            break;
-        }
-    }
-    return source;
-};
-var setIn = function (segments, source, value) {
-    for (var i = 0; i < segments.length; i++) {
-        var index = segments[i];
-        var rules = getDestructor(index);
-        if (!rules) {
-            if (!isValid(source) || !isAssignable(source))
-                return;
-            if (isArr(source) && !isNumberIndex(index)) {
-                return;
-            }
-            if (!isValid(source[index])) {
-                if (value === undefined) {
-                    if (source[index] === null)
-                        source[index] = value;
-                    return;
-                }
-                if (i < segments.length - 1) {
-                    source[index] = isNum(segments[i + 1]) ? [] : {};
-                }
-            }
-            if (i === segments.length - 1) {
-                source[index] = value;
-            }
-            source = source[index];
-        }
-        else {
-            setInByDestructor(source, rules, value, { setIn: setIn, getIn: getIn });
-            break;
-        }
-    }
-};
-var deleteIn = function (segments, source) {
-    for (var i = 0; i < segments.length; i++) {
-        var index = segments[i];
-        var rules = getDestructor(index);
-        if (!rules) {
-            if (i === segments.length - 1 && isValid(source)) {
-                delete source[index];
-                return;
-            }
-            if (!isValid(source) || !isAssignable(source))
-                return;
-            source = source[index];
-            if (!isObj(source)) {
-                return;
-            }
-        }
-        else {
-            deleteInByDestructor(source, rules, {
-                setIn: setIn,
-                getIn: getIn,
-                deleteIn: deleteIn,
-            });
-            break;
-        }
-    }
-};
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-var existIn = function (segments, source, start) {
-    if (start instanceof Path) {
-        start = start.length;
-    }
-    for (var i = start; i < segments.length; i++) {
-        var index = segments[i];
-        var rules = getDestructor(index);
-        if (!rules) {
-            if (i === segments.length - 1) {
-                return hasOwnProperty.call(source, index);
-            }
-            if (!isValid(source) || !isAssignable(source))
-                return false;
-            source = source[index];
-            if (!isObj(source)) {
-                return false;
-            }
-        }
-        else {
-            return existInByDestructor(source, rules, start, {
-                setIn: setIn,
-                getIn: getIn,
-                deleteIn: deleteIn,
-                existIn: existIn,
-            });
-        }
-    }
-};
-var parse = function (pattern, base) {
-    if (pattern instanceof Path) {
-        return {
-            entire: pattern.entire,
-            segments: pattern.segments.slice(),
-            isRegExp: false,
-            haveRelativePattern: pattern.haveRelativePattern,
-            isWildMatchPattern: pattern.isWildMatchPattern,
-            isMatchPattern: pattern.isMatchPattern,
-            haveExcludePattern: pattern.haveExcludePattern,
-            tree: pattern.tree,
-        };
-    }
-    else if (isStr(pattern)) {
-        if (!pattern) {
-            return {
-                entire: '',
-                segments: [],
-                isRegExp: false,
-                isWildMatchPattern: false,
-                haveExcludePattern: false,
-                isMatchPattern: false,
-            };
-        }
-        if (isSimplePath(pattern)) {
-            return {
-                entire: pattern,
-                segments: pattern.split('.'),
-                isRegExp: false,
-                isWildMatchPattern: false,
-                haveExcludePattern: false,
-                isMatchPattern: false,
-            };
-        }
-        var parser = new Parser(pattern, Path.parse(base));
-        var tree = parser.parse();
-        if (!parser.isMatchPattern) {
-            var segments = parser.data.segments;
-            return {
-                entire: segments.join('.'),
-                segments: segments,
-                tree: tree,
-                isRegExp: false,
-                haveRelativePattern: parser.haveRelativePattern,
-                isWildMatchPattern: false,
-                haveExcludePattern: false,
-                isMatchPattern: false,
-            };
-        }
-        else {
-            return {
-                entire: pattern,
-                segments: [],
-                isRegExp: false,
-                haveRelativePattern: false,
-                isWildMatchPattern: parser.isWildMatchPattern,
-                haveExcludePattern: parser.haveExcludePattern,
-                isMatchPattern: true,
-                tree: tree,
-            };
-        }
-    }
-    else if (isFn(pattern) && pattern[isMatcher]) {
-        return parse(pattern['path']);
-    }
-    else if (isArr(pattern)) {
-        return {
-            entire: pattern.join('.'),
-            segments: pattern.reduce(function (buf, key) {
-                return buf.concat(parseString(key));
-            }, []),
-            isRegExp: false,
-            haveRelativePattern: false,
-            isWildMatchPattern: false,
-            haveExcludePattern: false,
-            isMatchPattern: false,
-        };
-    }
-    else if (isRegExp(pattern)) {
-        return {
-            entire: pattern,
-            segments: [],
-            isRegExp: true,
-            haveRelativePattern: false,
-            isWildMatchPattern: false,
-            haveExcludePattern: false,
-            isMatchPattern: true,
-        };
-    }
-    else {
-        return {
-            entire: '',
-            isRegExp: false,
-            segments: pattern !== undefined ? [pattern] : [],
-            haveRelativePattern: false,
-            isWildMatchPattern: false,
-            haveExcludePattern: false,
-            isMatchPattern: false,
-        };
-    }
-};
-var parseString = function (source) {
-    if (isStr(source)) {
-        source = source.replace(/\s*/g, '');
-        try {
-            var _a = parse(source), segments = _a.segments, isMatchPattern = _a.isMatchPattern;
-            return !isMatchPattern ? segments : source;
-        }
-        catch (e) {
-            return source;
-        }
-    }
-    else if (source instanceof Path) {
-        return source.segments;
-    }
-    return source;
-};
-var Path = /** @class */ (function () {
-    function Path(input, base) {
-        var _this = this;
-        this.concat = function () {
-            var _a;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            if (_this.isMatchPattern || _this.isRegExp) {
-                throw new Error("".concat(_this.entire, " cannot be concat"));
-            }
-            var path = new Path('');
-            path.segments = (_a = _this.segments).concat.apply(_a, __spreadArray([], __read(args.map(function (s) { return parseString(s); })), false));
-            path.entire = path.segments.join('.');
-            return path;
-        };
-        this.slice = function (start, end) {
-            if (_this.isMatchPattern || _this.isRegExp) {
-                throw new Error("".concat(_this.entire, " cannot be slice"));
-            }
-            var path = new Path('');
-            path.segments = _this.segments.slice(start, end);
-            path.entire = path.segments.join('.');
-            return path;
-        };
-        this.push = function () {
-            var items = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                items[_i] = arguments[_i];
-            }
-            return _this.concat.apply(_this, __spreadArray([], __read(items), false));
-        };
-        this.pop = function () {
-            if (_this.isMatchPattern || _this.isRegExp) {
-                throw new Error("".concat(_this.entire, " cannot be pop"));
-            }
-            return new Path(_this.segments.slice(0, _this.segments.length - 1));
-        };
-        this.splice = function (start, deleteCount) {
-            var items = [];
-            for (var _i = 2; _i < arguments.length; _i++) {
-                items[_i - 2] = arguments[_i];
-            }
-            if (_this.isMatchPattern || _this.isRegExp) {
-                throw new Error("".concat(_this.entire, " cannot be splice"));
-            }
-            items = items.reduce(function (buf, item) { return buf.concat(parseString(item)); }, []);
-            var segments_ = _this.segments.slice();
-            segments_.splice.apply(segments_, __spreadArray([start, deleteCount], __read(items), false));
-            return new Path(segments_);
-        };
-        this.forEach = function (callback) {
-            if (_this.isMatchPattern || _this.isRegExp) {
-                throw new Error("".concat(_this.entire, " cannot be each"));
-            }
-            _this.segments.forEach(callback);
-        };
-        this.map = function (callback) {
-            if (_this.isMatchPattern || _this.isRegExp) {
-                throw new Error("".concat(_this.entire, " cannot be map"));
-            }
-            return _this.segments.map(callback);
-        };
-        this.reduce = function (callback, initial) {
-            if (_this.isMatchPattern || _this.isRegExp) {
-                throw new Error("".concat(_this.entire, " cannot be reduce"));
-            }
-            return _this.segments.reduce(callback, initial);
-        };
-        this.parent = function () {
-            return _this.slice(0, _this.length - 1);
-        };
-        this.includes = function (pattern) {
-            var _a = Path.parse(pattern), entire = _a.entire, segments = _a.segments, isMatchPattern = _a.isMatchPattern;
-            var cache = _this.includesCache.get(entire);
-            if (cache !== undefined)
-                return cache;
-            var cacheWith = function (value) {
-                _this.includesCache.set(entire, value);
-                return value;
-            };
-            if (_this.isMatchPattern) {
-                if (!isMatchPattern) {
-                    return cacheWith(_this.match(segments));
-                }
-                else {
-                    throw new Error("".concat(_this.entire, " cannot be used to match ").concat(entire));
-                }
-            }
-            if (isMatchPattern) {
-                throw new Error("".concat(_this.entire, " cannot be used to match ").concat(entire));
-            }
-            if (segments.length > _this.segments.length)
-                return cacheWith(false);
-            for (var i = 0; i < segments.length; i++) {
-                if (!isEqual(String(segments[i]), String(_this.segments[i]))) {
-                    return cacheWith(false);
-                }
-            }
-            return cacheWith(true);
-        };
-        this.transform = function (regexp, callback) {
-            if (!isFn(callback))
-                return '';
-            if (_this.isMatchPattern) {
-                throw new Error("".concat(_this.entire, " cannot be transformed"));
-            }
-            var args = _this.segments.reduce(function (buf, key) {
-                return new RegExp(regexp).test(key) ? buf.concat(key) : buf;
-            }, []);
-            return callback.apply(void 0, __spreadArray([], __read(args), false));
-        };
-        this.match = function (pattern) {
-            var _a, _b;
-            var path = Path.parse(pattern);
-            var cache = _this.matchCache.get(path.entire);
-            if (cache !== undefined) {
-                if (cache.record && cache.record.score !== undefined) {
-                    _this.matchScore = cache.record.score;
-                }
-                return cache.matched;
-            }
-            var cacheWith = function (value) {
-                _this.matchCache.set(path.entire, value);
-                return value;
-            };
-            if (path.isMatchPattern) {
-                if (_this.isMatchPattern) {
-                    throw new Error("".concat(path.entire, " cannot match ").concat(_this.entire));
-                }
-                else {
-                    _this.matchScore = 0;
-                    return cacheWith(path.match(_this.segments));
-                }
-            }
-            else {
-                if (_this.isMatchPattern) {
-                    if (_this.isRegExp) {
-                        try {
-                            return (_b = (_a = _this['entire']) === null || _a === void 0 ? void 0 : _a['test']) === null || _b === void 0 ? void 0 : _b.call(_a, path.entire);
-                        }
-                        finally {
-                            _this.entire.lastIndex = 0;
-                        }
-                    }
-                    var record = {
-                        score: 0,
-                    };
-                    var result = cacheWith(new Matcher(_this.tree, record).match(path.segments));
-                    _this.matchScore = record.score;
-                    return result.matched;
-                }
-                else {
-                    var record = {
-                        score: 0,
-                    };
-                    var result = cacheWith(Matcher.matchSegments(_this.segments, path.segments, record));
-                    _this.matchScore = record.score;
-                    return result.matched;
-                }
-            }
-        };
-        //别名组匹配
-        this.matchAliasGroup = function (name, alias) {
-            var namePath = Path.parse(name);
-            var aliasPath = Path.parse(alias);
-            var nameMatched = _this.match(namePath);
-            var nameMatchedScore = _this.matchScore;
-            var aliasMatched = _this.match(aliasPath);
-            var aliasMatchedScore = _this.matchScore;
-            if (_this.haveExcludePattern) {
-                if (nameMatchedScore >= aliasMatchedScore) {
-                    return nameMatched;
-                }
-                else {
-                    return aliasMatched;
-                }
-            }
-            else {
-                return nameMatched || aliasMatched;
-            }
-        };
-        this.existIn = function (source, start) {
-            if (start === void 0) { start = 0; }
-            return existIn(_this.segments, source, start);
-        };
-        this.getIn = function (source) {
-            return getIn(_this.segments, source);
-        };
-        this.setIn = function (source, value) {
-            setIn(_this.segments, source, value);
-            return source;
-        };
-        this.deleteIn = function (source) {
-            deleteIn(_this.segments, source);
-            return source;
-        };
-        this.ensureIn = function (source, defaults) {
-            var results = _this.getIn(source);
-            if (results === undefined) {
-                _this.setIn(source, defaults);
-                return _this.getIn(source);
-            }
-            return results;
-        };
-        var _a = parse(input, base), tree = _a.tree, segments = _a.segments, entire = _a.entire, isRegExp = _a.isRegExp, isMatchPattern = _a.isMatchPattern, isWildMatchPattern = _a.isWildMatchPattern, haveRelativePattern = _a.haveRelativePattern, haveExcludePattern = _a.haveExcludePattern;
-        this.entire = entire;
-        this.segments = segments;
-        this.isMatchPattern = isMatchPattern;
-        this.isWildMatchPattern = isWildMatchPattern;
-        this.haveRelativePattern = haveRelativePattern;
-        this.isRegExp = isRegExp;
-        this.haveExcludePattern = haveExcludePattern;
-        this.tree = tree;
-        this.matchCache = new Map();
-        this.includesCache = new Map();
-    }
-    Path.prototype.toString = function () {
-        var _a;
-        return (_a = this.entire) === null || _a === void 0 ? void 0 : _a.toString();
-    };
-    Path.prototype.toArr = function () {
-        var _a;
-        return (_a = this.segments) === null || _a === void 0 ? void 0 : _a.slice();
-    };
-    Object.defineProperty(Path.prototype, "length", {
-        get: function () {
-            return this.segments.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Path.match = function (pattern) {
-        var path = Path.parse(pattern);
-        var matcher = function (target) {
-            return path.match(target);
-        };
-        matcher[isMatcher] = true;
-        matcher.path = path;
-        return matcher;
-    };
-    Path.isPathPattern = function (target) {
-        if (isStr(target) ||
-            isArr(target) ||
-            isRegExp(target) ||
-            (isFn(target) && target[isMatcher])) {
-            return true;
-        }
-        return false;
-    };
-    Path.transform = function (pattern, regexp, callback) {
-        return Path.parse(pattern).transform(regexp, callback);
-    };
-    Path.parse = function (path, base) {
-        if (path === void 0) { path = ''; }
-        if (path instanceof Path) {
-            var found = pathCache.get(path.entire);
-            if (found) {
-                return found;
-            }
-            else {
-                pathCache.set(path.entire, path);
-                return path;
-            }
-        }
-        else if (path && path[isMatcher]) {
-            return Path.parse(path['path']);
-        }
-        else {
-            var key_ = base ? Path.parse(base) : '';
-            var key = "".concat(path, ":").concat(key_);
-            var found = pathCache.get(key);
-            if (found) {
-                return found;
-            }
-            else {
-                path = new Path(path, base);
-                pathCache.set(key, path);
-                return path;
-            }
-        }
-    };
-    Path.getIn = function (source, pattern) {
-        var path = Path.parse(pattern);
-        return path.getIn(source);
-    };
-    Path.setIn = function (source, pattern, value) {
-        var path = Path.parse(pattern);
-        return path.setIn(source, value);
-    };
-    Path.deleteIn = function (source, pattern) {
-        var path = Path.parse(pattern);
-        return path.deleteIn(source);
-    };
-    Path.existIn = function (source, pattern, start) {
-        var path = Path.parse(pattern);
-        return path.existIn(source, start);
-    };
-    Path.ensureIn = function (source, pattern, defaultValue) {
-        var path = Path.parse(pattern);
-        return path.ensureIn(source, defaultValue);
-    };
-    return Path;
-}());
-
-export { Path };