cnhis-design-vue 3.1.14-beta.7.1 → 3.1.14

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

@@ -0,0 +1,199 @@
+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

@@ -0,0 +1,402 @@
+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

@@ -0,0 +1,73 @@
+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 };