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

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

@@ -0,0 +1,287 @@
+import { eofTok, nameTok, ignoreTok, bracketDRTok, braceLTok, braceRTok, dbStarTok, starTok, bangTok, dotTok, bracketDLTok, bracketLTok, expandTok, bracketRTok, parenLTok, parenRTok, commaTok, colonTok } from './tokens.js';
+import { bracketDContext } from './contexts.js';
+
+var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+var fullCharCodeAtPos = function (input, pos) {
+    if (String.fromCharCode)
+        return input.codePointAt(pos);
+    var code = input.charCodeAt(pos);
+    if (code <= 0xd7ff || code >= 0xe000)
+        return code;
+    var next = input.charCodeAt(pos + 1);
+    return (code << 10) + next - 0x35fdc00;
+};
+var isRewordCode = function (code) {
+    return code === 42 ||
+        code === 46 ||
+        code === 33 ||
+        code === 91 ||
+        code === 93 ||
+        code === 40 ||
+        code === 41 ||
+        code === 44 ||
+        code === 58 ||
+        code === 126 ||
+        code === 123 ||
+        code === 125;
+};
+var getError = function (message, props) {
+    var err = new Error(message);
+    Object.assign(err, props);
+    return err;
+};
+var slice = function (string, start, end) {
+    var str = '';
+    for (var i = start; i < end; i++) {
+        var ch = string.charAt(i);
+        if (ch !== '\\') {
+            str += ch;
+        }
+    }
+    return str;
+};
+var Tokenizer = /** @class */ (function () {
+    function Tokenizer(input) {
+        this.input = input;
+        this.state = {
+            context: [],
+            type: null,
+            pos: 0,
+        };
+        this.type_ = null;
+    }
+    Tokenizer.prototype.curContext = function () {
+        return this.state.context[this.state.context.length - 1];
+    };
+    Tokenizer.prototype.includesContext = function (context) {
+        for (var len = this.state.context.length - 1; len >= 0; len--) {
+            if (this.state.context[len] === context) {
+                return true;
+            }
+        }
+        return false;
+    };
+    Tokenizer.prototype.unexpect = function (type) {
+        type = type || this.state.type;
+        return getError("Unexpect token \"".concat(type.flag, "\" in ").concat(this.state.pos, " char."), {
+            pos: this.state.pos,
+        });
+    };
+    Tokenizer.prototype.expectNext = function (type, next) {
+        if (type && type.expectNext) {
+            if (next && !type.expectNext.call(this, next)) {
+                throw getError("Unexpect token \"".concat(next.flag, "\" token should not be behind \"").concat(type.flag, "\" token.(").concat(this.state.pos, "th char)"), {
+                    pos: this.state.pos,
+                });
+            }
+        }
+    };
+    Tokenizer.prototype.expectPrev = function (type, prev) {
+        if (type && type.expectPrev) {
+            if (prev && !type.expectPrev.call(this, prev)) {
+                throw getError("Unexpect token \"".concat(type.flag, "\" should not be behind \"").concat(prev.flag, "\"(").concat(this.state.pos, "th char)."), {
+                    pos: this.state.pos,
+                });
+            }
+        }
+    };
+    Tokenizer.prototype.match = function (type) {
+        return this.state.type === type;
+    };
+    Tokenizer.prototype.skipSpace = function () {
+        if (this.curContext() === bracketDContext)
+            return;
+        loop: while (this.state.pos < this.input.length) {
+            var ch = this.input.charCodeAt(this.state.pos);
+            switch (ch) {
+                case 32:
+                case 160:
+                    ++this.state.pos;
+                    break;
+                case 13:
+                    if (this.input.charCodeAt(this.state.pos + 1) === 10) {
+                        ++this.state.pos;
+                    }
+                case 10:
+                case 8232:
+                case 8233:
+                    ++this.state.pos;
+                    break;
+                default:
+                    if ((ch > 8 && ch < 14) ||
+                        (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch)))) {
+                        ++this.state.pos;
+                    }
+                    else {
+                        break loop;
+                    }
+            }
+        }
+    };
+    Tokenizer.prototype.next = function () {
+        this.type_ = this.state.type;
+        if (this.input.length <= this.state.pos) {
+            return this.finishToken(eofTok);
+        }
+        this.skipSpace();
+        this.readToken(this.getCode(), this.state.pos > 0 ? this.getCode(this.state.pos - 1) : -Infinity);
+    };
+    Tokenizer.prototype.getCode = function (pos) {
+        if (pos === void 0) { pos = this.state.pos; }
+        return fullCharCodeAtPos(this.input, pos);
+    };
+    Tokenizer.prototype.eat = function (type) {
+        if (this.match(type)) {
+            this.next();
+            return true;
+        }
+        else {
+            return false;
+        }
+    };
+    Tokenizer.prototype.readKeyWord = function () {
+        var startPos = this.state.pos, string = '';
+        while (true) {
+            var code = this.getCode();
+            var prevCode = this.getCode(this.state.pos - 1);
+            if (this.input.length === this.state.pos) {
+                string = slice(this.input, startPos, this.state.pos + 1);
+                break;
+            }
+            if (!isRewordCode(code) || prevCode === 92) {
+                if (code === 32 ||
+                    code === 160 ||
+                    code === 10 ||
+                    code === 8232 ||
+                    code === 8233) {
+                    string = slice(this.input, startPos, this.state.pos);
+                    break;
+                }
+                if (code === 13 && this.input.charCodeAt(this.state.pos + 1) === 10) {
+                    string = slice(this.input, startPos, this.state.pos);
+                    break;
+                }
+                if ((code > 8 && code < 14) ||
+                    (code >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(code)))) {
+                    string = slice(this.input, startPos, this.state.pos);
+                    break;
+                }
+                this.state.pos++;
+            }
+            else {
+                string = slice(this.input, startPos, this.state.pos);
+                break;
+            }
+        }
+        this.finishToken(nameTok, string);
+    };
+    Tokenizer.prototype.readIngoreString = function () {
+        var startPos = this.state.pos, prevCode, string = '';
+        while (true) {
+            var code = this.getCode();
+            if (this.state.pos >= this.input.length)
+                break;
+            if ((code === 91 || code === 93) && prevCode === 92) {
+                this.state.pos++;
+                prevCode = '';
+            }
+            else if (code == 93 && prevCode === 93) {
+                string = this.input
+                    .slice(startPos, this.state.pos - 1)
+                    .replace(/\\([\[\]])/g, '$1');
+                this.state.pos++;
+                break;
+            }
+            else {
+                this.state.pos++;
+                prevCode = code;
+            }
+        }
+        this.finishToken(ignoreTok, string);
+        this.finishToken(bracketDRTok);
+    };
+    Tokenizer.prototype.finishToken = function (type, value) {
+        var preType = this.state.type;
+        this.state.type = type;
+        if (value !== undefined)
+            this.state.value = value;
+        this.expectNext(preType, type);
+        this.expectPrev(type, preType);
+        if (type.updateContext) {
+            type.updateContext.call(this, preType);
+        }
+    };
+    Tokenizer.prototype.readToken = function (code, prevCode) {
+        if (prevCode === 92) {
+            return this.readKeyWord();
+        }
+        if (this.input.length <= this.state.pos) {
+            this.finishToken(eofTok);
+        }
+        else if (this.curContext() === bracketDContext) {
+            this.readIngoreString();
+        }
+        else if (code === 123) {
+            this.state.pos++;
+            this.finishToken(braceLTok);
+        }
+        else if (code === 125) {
+            this.state.pos++;
+            this.finishToken(braceRTok);
+        }
+        else if (code === 42) {
+            this.state.pos++;
+            if (this.getCode() === 42) {
+                this.state.pos++;
+                return this.finishToken(dbStarTok);
+            }
+            this.finishToken(starTok);
+        }
+        else if (code === 33) {
+            this.state.pos++;
+            this.finishToken(bangTok);
+        }
+        else if (code === 46) {
+            this.state.pos++;
+            this.finishToken(dotTok);
+        }
+        else if (code === 91) {
+            this.state.pos++;
+            if (this.getCode() === 91) {
+                this.state.pos++;
+                return this.finishToken(bracketDLTok);
+            }
+            this.finishToken(bracketLTok);
+        }
+        else if (code === 126) {
+            this.state.pos++;
+            this.finishToken(expandTok);
+        }
+        else if (code === 93) {
+            this.state.pos++;
+            this.finishToken(bracketRTok);
+        }
+        else if (code === 40) {
+            this.state.pos++;
+            this.finishToken(parenLTok);
+        }
+        else if (code === 41) {
+            this.state.pos++;
+            this.finishToken(parenRTok);
+        }
+        else if (code === 44) {
+            this.state.pos++;
+            this.finishToken(commaTok);
+        }
+        else if (code === 58) {
+            this.state.pos++;
+            this.finishToken(colonTok);
+        }
+        else {
+            this.readKeyWord();
+        }
+    };
+    return Tokenizer;
+}());
+
+export { Tokenizer };

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

@@ -0,0 +1,240 @@
+import { destructorContext, braceContext, bracketContext, bracketArrayContext, bracketDContext, parenContext } from './contexts.js';
+
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var TokenType = function (flag, props) {
+    return __assign({ flag: flag }, props);
+};
+var nameTok = TokenType('name', {
+    expectNext: function (next) {
+        if (this.includesContext(destructorContext)) {
+            return (next === nameTok ||
+                next === commaTok ||
+                next === bracketRTok ||
+                next === braceRTok ||
+                next === colonTok);
+        }
+        return (next === dotTok ||
+            next === commaTok ||
+            next === eofTok ||
+            next === bracketRTok ||
+            next === parenRTok ||
+            next === colonTok ||
+            next === expandTok ||
+            next === bracketLTok);
+    },
+});
+var starTok = TokenType('*', {
+    expectNext: function (next) {
+        return (next === dotTok ||
+            next === parenLTok ||
+            next === bracketLTok ||
+            next === eofTok ||
+            next === commaTok ||
+            next === parenRTok);
+    },
+});
+var dbStarTok = TokenType('**', {
+    expectNext: function (next) {
+        return (next === dotTok ||
+            next === parenLTok ||
+            next === bracketLTok ||
+            next === eofTok ||
+            next === commaTok ||
+            next === parenRTok);
+    },
+});
+var dotTok = TokenType('.', {
+    expectNext: function (next) {
+        return (next === dotTok ||
+            next === nameTok ||
+            next === bracketDLTok ||
+            next === starTok ||
+            next === dbStarTok ||
+            next === bracketLTok ||
+            next === braceLTok ||
+            next === eofTok);
+    },
+    expectPrev: function (prev) {
+        return (prev === dotTok ||
+            prev === nameTok ||
+            prev === bracketDRTok ||
+            prev === starTok ||
+            prev === parenRTok ||
+            prev === bracketRTok ||
+            prev === expandTok ||
+            prev === braceRTok);
+    },
+});
+var bangTok = TokenType('!', {
+    expectNext: function (next) {
+        return next === nameTok || next === bracketDLTok;
+    },
+});
+var colonTok = TokenType(':', {
+    expectNext: function (next) {
+        if (this.includesContext(destructorContext)) {
+            return next === nameTok || next === braceLTok || next === bracketLTok;
+        }
+        return next === nameTok || next === bracketDLTok || next === bracketRTok;
+    },
+});
+var braceLTok = TokenType('{', {
+    expectNext: function (next) {
+        return next === nameTok;
+    },
+    expectPrev: function (prev) {
+        if (this.includesContext(destructorContext)) {
+            return prev === colonTok || prev === commaTok || prev === bracketLTok;
+        }
+        return prev === dotTok || prev === colonTok || prev === parenLTok;
+    },
+    updateContext: function () {
+        this.state.context.push(braceContext);
+    },
+});
+var braceRTok = TokenType('}', {
+    expectNext: function (next) {
+        if (this.includesContext(destructorContext)) {
+            return (next === commaTok ||
+                next === braceRTok ||
+                next === eofTok ||
+                next === bracketRTok);
+        }
+        return next === dotTok || next === eofTok || next === commaTok;
+    },
+    expectPrev: function (prev) {
+        return prev === nameTok || prev === braceRTok || prev === bracketRTok;
+    },
+    updateContext: function () {
+        this.state.context.pop(braceContext);
+    },
+});
+var bracketLTok = TokenType('[', {
+    expectNext: function (next) {
+        if (this.includesContext(destructorContext)) {
+            return (next === nameTok ||
+                next === bracketLTok ||
+                next === braceLTok ||
+                next === bracketRTok);
+        }
+        return (next === nameTok ||
+            next === bracketDLTok ||
+            next === colonTok ||
+            next === bracketLTok ||
+            next === ignoreTok ||
+            next === bracketRTok);
+    },
+    expectPrev: function (prev) {
+        if (this.includesContext(destructorContext)) {
+            return prev === colonTok || prev === commaTok || prev === bracketLTok;
+        }
+        return (prev === starTok ||
+            prev === bracketLTok ||
+            prev === dotTok ||
+            prev === nameTok ||
+            prev === parenLTok ||
+            prev == commaTok);
+    },
+    updateContext: function () {
+        this.state.context.push(bracketContext);
+    },
+});
+var bracketRTok = TokenType(']', {
+    expectNext: function (next) {
+        if (this.includesContext(destructorContext)) {
+            return (next === commaTok ||
+                next === braceRTok ||
+                next === bracketRTok ||
+                next === eofTok);
+        }
+        return (next === dotTok ||
+            next === eofTok ||
+            next === commaTok ||
+            next === parenRTok ||
+            next === bracketRTok);
+    },
+    updateContext: function () {
+        if (this.includesContext(bracketArrayContext))
+            return;
+        if (!this.includesContext(bracketContext))
+            throw this.unexpect();
+        this.state.context.pop();
+    },
+});
+var bracketDLTok = TokenType('[[', {
+    updateContext: function () {
+        this.state.context.push(bracketDContext);
+    },
+});
+var bracketDRTok = TokenType(']]', {
+    updateContext: function () {
+        if (this.curContext() !== bracketDContext)
+            throw this.unexpect();
+        this.state.context.pop();
+    },
+});
+var parenLTok = TokenType('(', {
+    expectNext: function (next) {
+        return (next === nameTok ||
+            next === bracketDLTok ||
+            next === braceLTok ||
+            next === bangTok ||
+            next === bracketLTok);
+    },
+    expectPrev: function (prev) {
+        return prev === starTok;
+    },
+    updateContext: function () {
+        this.state.context.push(parenContext);
+    },
+});
+var parenRTok = TokenType(')', {
+    expectNext: function (next) {
+        return (next === dotTok ||
+            next === eofTok ||
+            next === commaTok ||
+            next === parenRTok);
+    },
+    updateContext: function () {
+        if (this.curContext() !== parenContext)
+            throw this.unexpect();
+        this.state.context.pop();
+    },
+});
+var commaTok = TokenType(',', {
+    expectNext: function (next) {
+        return (next === nameTok ||
+            next === bracketDLTok ||
+            next === bracketLTok ||
+            next === braceLTok);
+    },
+});
+var ignoreTok = TokenType('ignore', {
+    expectNext: function (next) {
+        return next === bracketDRTok;
+    },
+    expectPrev: function (prev) {
+        return prev == bracketDLTok;
+    },
+});
+var expandTok = TokenType('expandTok', {
+    expectNext: function (next) {
+        return (next === dotTok ||
+            next === eofTok ||
+            next === commaTok ||
+            next === parenRTok);
+    },
+});
+var eofTok = TokenType('eof');
+
+export { bangTok, braceLTok, braceRTok, bracketDLTok, bracketDRTok, bracketLTok, bracketRTok, colonTok, commaTok, dbStarTok, dotTok, eofTok, expandTok, ignoreTok, nameTok, parenLTok, parenRTok, starTok };

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

@@ -0,0 +1,17 @@
+var isType = function (type) {
+    return function (obj) {
+        return obj && obj.type === type;
+    };
+};
+var isIdentifier = isType('Identifier');
+var isIgnoreExpression = isType('IgnoreExpression');
+var isDotOperator = isType('DotOperator');
+var isWildcardOperator = isType('WildcardOperator');
+var isExpandOperator = isType('ExpandOperator');
+var isGroupExpression = isType('GroupExpression');
+var isRangeExpression = isType('RangeExpression');
+var isDestructorExpression = isType('DestructorExpression');
+var isObjectPattern = isType('ObjectPattern');
+var isArrayPattern = isType('ArrayPattern');
+
+export { isArrayPattern, isDestructorExpression, isDotOperator, isExpandOperator, isGroupExpression, isIdentifier, isIgnoreExpression, isObjectPattern, isRangeExpression, isType, isWildcardOperator };

package/es/packages/big-table/index.d.ts

@@ -9,6 +9,10 @@ declare const BigTable: SFCWithInstall<import("vue").DefineComponent<{
         type: NumberConstructor;
         default: number;
     };
+    checkboxBindRowClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     showFooter: BooleanConstructor;
     sumData: {
         type: ObjectConstructor;
@@ -2591,6 +2595,10 @@ declare const BigTable: SFCWithInstall<import("vue").DefineComponent<{
             type: NumberConstructor;
             default: number;
         };
+        checkboxBindRowClick: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
         showFooter: BooleanConstructor;
         sumData: {
             type: ObjectConstructor;
@@ -2928,6 +2936,7 @@ declare const BigTable: SFCWithInstall<import("vue").DefineComponent<{
     handleFilterSearchChange: (value: any, columnName: any, field: any) => void;
     handleFilterClearAll: (field: any) => void;
     handleCancelFilter: () => void;
+    mergeQuickSearchConfig: (filterFields: any, props: any) => void;
     handleFilter: (field: any) => void;
     onmousedownFunc: (e: any) => void;
     maskInsert: () => void;
@@ -4073,6 +4082,10 @@ declare const BigTable: SFCWithInstall<import("vue").DefineComponent<{
         type: NumberConstructor;
         default: number;
     };
+    checkboxBindRowClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     showFooter: BooleanConstructor;
     sumData: {
         type: ObjectConstructor;
@@ -4268,6 +4281,7 @@ declare const BigTable: SFCWithInstall<import("vue").DefineComponent<{
     columnConfig: Record<string, any>;
     menuConfig: Record<string, any>;
     maxCheckSize: number;
+    checkboxBindRowClick: boolean;
     sumData: Record<string, any>;
     avgData: Record<string, any>;
     refreshRow: number;

package/es/packages/big-table/index.js

@@ -3,8 +3,7 @@ import { safeComponentRegister } from '../../src/utils';
 import { loadVxeTable } from '../../src/utils/loadVxe';
 import { expandXEUtils } from '../../src/utils/utilExpand';
 import { CGrid } from '../../packages/index';
-import './src/BigTable.js';
-import script from './src/BigTable.vue_vue_type_script_setup_true_lang.js';
+import script from './src/BigTable.js';
 export { useColumnConfigAdaptor } from './src/hooks/useColumnConfigAdaptor.js';
 
 const BigTable = script;

package/es/packages/big-table/src/BigTable.js

@@ -1,4 +1,6 @@
-import script from './BigTable.vue_vue_type_script_setup_true_lang.js';
-export { default } from './BigTable.vue_vue_type_script_setup_true_lang.js';
+import _sfc_main from './BigTable.vue_vue_type_script_setup_true_lang.js';
+import _export_sfc from '../../../_virtual/plugin-vue_export-helper.js';
 
-script.__file = "packages/big-table/src/BigTable.vue";
+var script = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "BigTable.vue"]]);
+
+export { script as default };