cnhis-design-vue 3.1.15-beta.1 → 3.1.15-beta.10

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

@@ -1,199 +0,0 @@
-import { isWildcardOperator, isExpandOperator, isDotOperator, isIdentifier, isIgnoreExpression, isDestructorExpression, isGroupExpression, isRangeExpression } from './types.js';
-import { isEqual, toArr, isSegmentEqual } from './shared.js';
-
-var Matcher = /** @class */ (function () {
-    function Matcher(tree, record) {
-        this.tree = tree;
-        this.stack = [];
-        this.excluding = false;
-        this.wildcards = [];
-        this.record = record;
-    }
-    Matcher.prototype.next = function (node, pos) {
-        var isLastToken = pos === this.path.length - 1;
-        //  const isOverToken = pos > this.path.length
-        if (node.after) {
-            // if (isOverToken) {
-            //   return false
-            // }
-            return this.matchNode(node.after, pos);
-        }
-        if (isWildcardOperator(node) && !node.filter) {
-            if (this.excluding) {
-                return false;
-            }
-            else {
-                if (pos === 0 || node.optional)
-                    return true;
-                return !!this.take(pos);
-            }
-        }
-        if (isLastToken) {
-            return !!this.take(pos);
-        }
-        else {
-            var wildcard = this.wildcards.pop();
-            if (wildcard && wildcard.after) {
-                return this.next(wildcard, pos);
-            }
-        }
-        return false;
-    };
-    Matcher.prototype.shot = function () {
-        var _a;
-        if (((_a = this.record) === null || _a === void 0 ? void 0 : _a.score) >= 0) {
-            this.record.score++;
-        }
-    };
-    Matcher.prototype.take = function (pos) {
-        var _a;
-        return String((_a = this.path[pos]) !== null && _a !== void 0 ? _a : '');
-    };
-    Matcher.prototype.matchExcludeIdentifier = function (matched, node, pos) {
-        var isLastToken = pos === this.path.length - 1;
-        var isContainToken = pos < this.path.length;
-        if (!node.after) {
-            this.excluding = false;
-        }
-        if (matched) {
-            if (node.after) {
-                return this.next(node, pos);
-            }
-            if (isLastToken) {
-                return false;
-            }
-        }
-        if (isLastToken) {
-            return true;
-        }
-        return isContainToken;
-    };
-    Matcher.prototype.matchIdentifier = function (node, pos) {
-        var current = this.take(pos);
-        var matched = false;
-        if (isExpandOperator(node.after)) {
-            if (current.indexOf(node.value) === 0) {
-                this.shot();
-                matched = true;
-            }
-            if (this.excluding) {
-                return this.matchExcludeIdentifier(matched, node.after, pos);
-            }
-            else {
-                return matched && this.next(node.after, pos);
-            }
-        }
-        else if (current === node.value) {
-            this.shot();
-            matched = true;
-        }
-        if (this.excluding) {
-            return this.matchExcludeIdentifier(matched, node, pos);
-        }
-        else {
-            return matched && this.next(node, pos);
-        }
-    };
-    Matcher.prototype.matchIgnoreExpression = function (node, pos) {
-        return isEqual(node.value, this.take(pos)) && this.next(node, pos);
-    };
-    Matcher.prototype.matchDestructorExpression = function (node, pos) {
-        return isEqual(node.source, this.take(pos)) && this.next(node, pos);
-    };
-    Matcher.prototype.matchExpandOperator = function (node, pos) {
-        return this.next(node, pos);
-    };
-    Matcher.prototype.matchWildcardOperator = function (node, pos) {
-        var matched = false;
-        if (node.filter) {
-            this.stack.push(node);
-            matched = this.matchNode(node.filter, pos);
-            this.stack.pop();
-        }
-        else {
-            matched = this.next(node, pos);
-        }
-        return matched;
-    };
-    Matcher.prototype.matchGroupExpression = function (node, pos) {
-        var _this = this;
-        var excluding = false;
-        if (node.isExclude) {
-            excluding = !this.excluding;
-        }
-        return toArr(node.value)[excluding ? 'every' : 'some'](function (item) {
-            _this.wildcards = _this.stack.slice();
-            _this.excluding = excluding;
-            return _this.matchNode(item, pos);
-        });
-    };
-    Matcher.prototype.matchRangeExpression = function (node, pos) {
-        var current = Number(this.take(pos));
-        if (node.start) {
-            if (node.end) {
-                return (current >= Number(node.start.value) &&
-                    current <= Number(node.end.value));
-            }
-            else {
-                return current >= Number(node.start.value);
-            }
-        }
-        else {
-            if (node.end) {
-                return current <= Number(node.end.value);
-            }
-            else {
-                this.wildcards = this.stack.slice();
-                return this.next(node, pos);
-            }
-        }
-    };
-    Matcher.prototype.matchNode = function (node, pos) {
-        if (pos === void 0) { pos = 0; }
-        if (isDotOperator(node)) {
-            return this.next(node, pos + 1);
-        }
-        else if (isIdentifier(node)) {
-            return this.matchIdentifier(node, pos);
-        }
-        else if (isIgnoreExpression(node)) {
-            return this.matchIgnoreExpression(node, pos);
-        }
-        else if (isDestructorExpression(node)) {
-            return this.matchDestructorExpression(node, pos);
-        }
-        else if (isExpandOperator(node)) {
-            return this.matchExpandOperator(node, pos);
-        }
-        else if (isWildcardOperator(node)) {
-            return this.matchWildcardOperator(node, pos);
-        }
-        else if (isGroupExpression(node)) {
-            return this.matchGroupExpression(node, pos);
-        }
-        else if (isRangeExpression(node)) {
-            return this.matchRangeExpression(node, pos);
-        }
-        return false;
-    };
-    Matcher.prototype.match = function (path) {
-        this.path = path;
-        return { matched: this.matchNode(this.tree), record: this.record };
-    };
-    Matcher.matchSegments = function (source, target, record) {
-        if (source.length !== target.length)
-            return { matched: false, record: record };
-        var match = function (pos) {
-            if (pos === void 0) { pos = 0; }
-            var current = isSegmentEqual(source[pos], target[pos]);
-            if ((record === null || record === void 0 ? void 0 : record.score) >= 0) {
-                record.score++;
-            }
-            return current && (pos < source.length - 1 ? match(pos + 1) : true);
-        };
-        return { matched: match(), record: record };
-    };
-    return Matcher;
-}());
-
-export { Matcher };

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

@@ -1,402 +0,0 @@
-import { Tokenizer } from './tokenizer.js';
-import { eofTok, dotTok, bracketDLTok, starTok, dbStarTok, expandTok, nameTok, bracketLTok, braceLTok, bracketRTok, parenLTok, braceRTok, colonTok, parenRTok, bangTok, commaTok } from './tokens.js';
-import { destructorContext, bracketArrayContext } from './contexts.js';
-import { setDestructor, parseDestructorRules } from './destructor.js';
-import { isNumberLike } from './shared.js';
-
-var __extends = (undefined && undefined.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var createTreeBySegments = function (segments, afterNode) {
-    if (segments === void 0) { segments = []; }
-    var segLen = segments.length;
-    var build = function (start) {
-        if (start === void 0) { start = 0; }
-        var after = start < segLen - 1 ? build(start + 1) : afterNode;
-        var dot = after && {
-            type: 'DotOperator',
-            after: after,
-        };
-        return {
-            type: 'Identifier',
-            value: segments[start],
-            after: dot,
-        };
-    };
-    return build();
-};
-var calculate = function (a, b, operator) {
-    if (isNumberLike(a) && isNumberLike(b)) {
-        if (operator === '+')
-            return String(Number(a) + Number(b));
-        if (operator === '-')
-            return String(Number(a) - Number(b));
-        if (operator === '*')
-            return String(Number(a) * Number(b));
-        if (operator === '/')
-            return String(Number(a) / Number(b));
-    }
-    else {
-        if (operator === '+')
-            return String(a) + String(b);
-        if (operator === '-')
-            return 'NaN';
-        if (operator === '*')
-            return 'NaN';
-        if (operator === '/')
-            return 'NaN';
-    }
-    return String(Number(b));
-};
-var Parser = /** @class */ (function (_super) {
-    __extends(Parser, _super);
-    function Parser(input, base) {
-        var _this = _super.call(this, input) || this;
-        _this.isMatchPattern = false;
-        _this.isWildMatchPattern = false;
-        _this.haveExcludePattern = false;
-        _this.haveRelativePattern = false;
-        _this.base = base;
-        return _this;
-    }
-    Parser.prototype.parse = function () {
-        var node;
-        this.data = {
-            segments: [],
-        };
-        if (!this.eat(eofTok)) {
-            this.next();
-            node = this.parseAtom(this.state.type);
-        }
-        this.data.tree = node;
-        return node;
-    };
-    Parser.prototype.append = function (parent, node) {
-        if (parent && node) {
-            parent.after = node;
-        }
-    };
-    Parser.prototype.parseAtom = function (type) {
-        switch (type) {
-            case braceLTok:
-            case bracketLTok:
-                if (this.includesContext(destructorContext)) {
-                    if (type === braceLTok) {
-                        return this.parseObjectPattern();
-                    }
-                    else {
-                        return this.parseArrayPattern();
-                    }
-                }
-                return this.parseDestructorExpression();
-            case nameTok:
-                return this.parseIdentifier();
-            case expandTok:
-                return this.parseExpandOperator();
-            case dbStarTok:
-            case starTok:
-                return this.parseWildcardOperator();
-            case bracketDLTok:
-                return this.parseIgnoreExpression();
-            case dotTok:
-                return this.parseDotOperator();
-        }
-    };
-    Parser.prototype.pushSegments = function (key) {
-        this.data.segments.push(key);
-    };
-    Parser.prototype.parseIdentifier = function () {
-        var node = {
-            type: 'Identifier',
-            value: this.state.value,
-        };
-        var hasNotInDestructor = !this.includesContext(destructorContext) &&
-            !this.isMatchPattern &&
-            !this.isWildMatchPattern;
-        this.next();
-        if (this.includesContext(bracketArrayContext)) {
-            if (this.state.type !== bracketRTok) {
-                throw this.unexpect();
-            }
-            else {
-                this.state.context.pop();
-                this.next();
-            }
-        }
-        else if (hasNotInDestructor) {
-            this.pushSegments(node.value);
-        }
-        if (this.state.type === bracketLTok) {
-            this.next();
-            if (this.state.type !== nameTok) {
-                throw this.unexpect();
-            }
-            this.state.context.push(bracketArrayContext);
-            var isNumberKey = false;
-            if (/^\d+$/.test(this.state.value)) {
-                isNumberKey = true;
-            }
-            var value = this.state.value;
-            this.pushSegments(isNumberKey ? Number(value) : value);
-            var after = this.parseAtom(this.state.type);
-            if (isNumberKey) {
-                after.arrayIndex = true;
-            }
-            this.append(node, after);
-        }
-        else {
-            this.append(node, this.parseAtom(this.state.type));
-        }
-        return node;
-    };
-    Parser.prototype.parseExpandOperator = function () {
-        var node = {
-            type: 'ExpandOperator',
-        };
-        this.isMatchPattern = true;
-        this.isWildMatchPattern = true;
-        this.data.segments = [];
-        this.next();
-        this.append(node, this.parseAtom(this.state.type));
-        return node;
-    };
-    Parser.prototype.parseWildcardOperator = function () {
-        var node = {
-            type: 'WildcardOperator',
-        };
-        if (this.state.type === dbStarTok) {
-            node.optional = true;
-        }
-        this.isMatchPattern = true;
-        this.isWildMatchPattern = true;
-        this.data.segments = [];
-        this.next();
-        if (this.state.type === parenLTok) {
-            node.filter = this.parseGroupExpression(node);
-        }
-        else if (this.state.type === bracketLTok) {
-            node.filter = this.parseRangeExpression(node);
-        }
-        this.append(node, this.parseAtom(this.state.type));
-        return node;
-    };
-    Parser.prototype.parseDestructorExpression = function () {
-        var _this = this;
-        var node = {
-            type: 'DestructorExpression',
-        };
-        this.state.context.push(destructorContext);
-        var startPos = this.state.pos - 1;
-        node.value =
-            this.state.type === braceLTok
-                ? this.parseObjectPattern()
-                : this.parseArrayPattern();
-        var endPos = this.state.pos;
-        this.state.context.pop();
-        node.source = this.input
-            .substring(startPos, endPos)
-            .replace(/\[\s*([\+\-\*\/])?\s*([^,\]\s]*)\s*\]/, function (match, operator, target) {
-            if (_this.relative !== undefined) {
-                if (operator) {
-                    if (target) {
-                        return calculate(_this.relative, target, operator);
-                    }
-                    else {
-                        return calculate(_this.relative, 1, operator);
-                    }
-                }
-                else {
-                    if (target) {
-                        return calculate(_this.relative, target, '+');
-                    }
-                    else {
-                        return String(_this.relative);
-                    }
-                }
-            }
-            return match;
-        })
-            .replace(/\s*\.\s*/g, '')
-            .replace(/\s*/g, '');
-        if (this.relative === undefined) {
-            setDestructor(node.source, parseDestructorRules(node));
-        }
-        this.relative = undefined;
-        this.pushSegments(node.source);
-        this.next();
-        this.append(node, this.parseAtom(this.state.type));
-        return node;
-    };
-    Parser.prototype.parseArrayPattern = function () {
-        var node = {
-            type: 'ArrayPattern',
-            elements: [],
-        };
-        this.next();
-        node.elements = this.parseArrayPatternElements();
-        return node;
-    };
-    Parser.prototype.parseArrayPatternElements = function () {
-        var nodes = [];
-        while (this.state.type !== bracketRTok && this.state.type !== eofTok) {
-            nodes.push(this.parseAtom(this.state.type));
-            if (this.state.type === bracketRTok) {
-                if (this.includesContext(destructorContext)) {
-                    this.next();
-                }
-                return nodes;
-            }
-            this.next();
-        }
-        return nodes;
-    };
-    Parser.prototype.parseObjectPattern = function () {
-        var node = {
-            type: 'ObjectPattern',
-            properties: [],
-        };
-        this.next();
-        node.properties = this.parseObjectProperties();
-        return node;
-    };
-    Parser.prototype.parseObjectProperties = function () {
-        var nodes = [];
-        while (this.state.type !== braceRTok && this.state.type !== eofTok) {
-            var node = {
-                type: 'ObjectPatternProperty',
-                key: this.parseAtom(this.state.type),
-            };
-            nodes.push(node);
-            if (this.state.type === colonTok) {
-                this.next();
-                node.value = this.parseAtom(this.state.type);
-            }
-            if (this.state.type === braceRTok) {
-                if (this.includesContext(destructorContext)) {
-                    this.next();
-                }
-                return nodes;
-            }
-            this.next();
-        }
-        return nodes;
-    };
-    Parser.prototype.parseDotOperator = function () {
-        var node = {
-            type: 'DotOperator',
-        };
-        var prevToken = this.type_;
-        if (!prevToken && this.base) {
-            if (this.base.isMatchPattern) {
-                throw new Error('Base path must be an absolute path.');
-            }
-            this.data.segments = this.base.toArr();
-            while (this.state.type === dotTok) {
-                this.relative = this.data.segments.pop();
-                this.haveRelativePattern = true;
-                this.next();
-            }
-            return createTreeBySegments(this.data.segments.slice(), this.parseAtom(this.state.type));
-        }
-        else {
-            this.next();
-        }
-        this.append(node, this.parseAtom(this.state.type));
-        return node;
-    };
-    Parser.prototype.parseIgnoreExpression = function () {
-        this.next();
-        var value = String(this.state.value).replace(/\s*/g, '');
-        var node = {
-            type: 'IgnoreExpression',
-            value: value,
-        };
-        this.pushSegments(value);
-        this.next();
-        this.append(node, this.parseAtom(this.state.type));
-        this.next();
-        return node;
-    };
-    Parser.prototype.parseGroupExpression = function (parent) {
-        var node = {
-            type: 'GroupExpression',
-            value: [],
-        };
-        this.isMatchPattern = true;
-        this.data.segments = [];
-        this.next();
-        loop: while (true) {
-            switch (this.state.type) {
-                case commaTok:
-                    this.next();
-                    break;
-                case bangTok:
-                    node.isExclude = true;
-                    this.haveExcludePattern = true;
-                    this.next();
-                    break;
-                case eofTok:
-                    break loop;
-                case parenRTok:
-                    break loop;
-                default:
-                    node.value.push(this.parseAtom(this.state.type));
-            }
-        }
-        this.next();
-        this.append(parent, this.parseAtom(this.state.type));
-        return node;
-    };
-    Parser.prototype.parseRangeExpression = function (parent) {
-        var node = {
-            type: 'RangeExpression',
-        };
-        this.next();
-        this.isMatchPattern = true;
-        this.data.segments = [];
-        var start = false, hasColon = false;
-        loop: while (true) {
-            switch (this.state.type) {
-                case colonTok:
-                    hasColon = true;
-                    start = true;
-                    this.next();
-                    break;
-                case bracketRTok:
-                    if (!hasColon && !node.end) {
-                        node.end = node.start;
-                    }
-                    break loop;
-                case commaTok:
-                    throw this.unexpect();
-                case eofTok:
-                    break loop;
-                default:
-                    if (!start) {
-                        node.start = this.parseAtom(this.state.type);
-                    }
-                    else {
-                        node.end = this.parseAtom(this.state.type);
-                    }
-            }
-        }
-        this.next();
-        this.append(parent, this.parseAtom(this.state.type));
-        return node;
-    };
-    return Parser;
-}(Tokenizer));
-
-export { Parser };

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

@@ -1,73 +0,0 @@
-var toString = Object.prototype.toString;
-var isType = function (type) {
-    return function (obj) {
-        return toString.call(obj) === "[object ".concat(type, "]");
-    };
-};
-var isFn = isType('Function');
-var isArr = Array.isArray || isType('Array');
-var isStr = isType('String');
-var isNum = isType('Number');
-var isObj = function (val) { return typeof val === 'object'; };
-var isRegExp = isType('RegExp');
-var isNumberLike = function (t) {
-    return isNum(t) || /^(\d+)(\.\d+)?$/.test(t);
-};
-var isArray = isArr;
-var keyList = Object.keys;
-var hasProp = Object.prototype.hasOwnProperty;
-var toArr = function (val) {
-    return Array.isArray(val) ? val : val !== undefined ? [val] : [];
-};
-var isEqual = function (a, b) {
-    if (a === b) {
-        return true;
-    }
-    if (a && b && typeof a === 'object' && typeof b === 'object') {
-        var arrA = isArray(a);
-        var arrB = isArray(b);
-        var i = void 0;
-        var length = void 0;
-        var key = void 0;
-        if (arrA && arrB) {
-            length = a.length;
-            if (length !== b.length) {
-                return false;
-            }
-            for (i = length; i-- !== 0;) {
-                if (!isEqual(a[i], b[i])) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        if (arrA !== arrB) {
-            return false;
-        }
-        var keys = keyList(a);
-        length = keys.length;
-        if (length !== keyList(b).length) {
-            return false;
-        }
-        for (i = length; i-- !== 0;) {
-            if (!hasProp.call(b, keys[i])) {
-                return false;
-            }
-        }
-        for (i = length; i-- !== 0;) {
-            key = keys[i];
-            if (!isEqual(a[key], b[key])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    return a !== a && b !== b;
-};
-var isSegmentEqual = function (a, b) {
-    a = typeof a === 'symbol' ? a : "".concat(a);
-    b = typeof b === 'symbol' ? b : "".concat(b);
-    return a === b;
-};
-
-export { isArr, isEqual, isFn, isNum, isNumberLike, isObj, isRegExp, isSegmentEqual, isStr, toArr };