cnhis-design-vue 3.1.14-beta.12 → 3.1.14-beta.15

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.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 };

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

@@ -11,20 +11,17 @@ import { useNestTable } from './hooks/useNestTable.js';
 import { useEdit, comps } from './hooks/useEdit.js';
 import { useEvent } from './hooks/useEvent.js';
 import { SettingsSharp, CaretDown, CaretForward, CopyOutline, SyncOutline } from '@vicons/ionicons5';
-import './components/NoData.js';
+import NoData from './components/NoData.js';
 import TextOverTooltip from '../../../src/components/TextOverTooltip';
 import SvgIcon from '../../../src/components/SvgIcon';
 import { useMessage, NIcon, NTooltip, NCheckbox, NCheckboxGroup, NGrid, NGi, NSpace, NButton, NPopconfirm, NProgress, NDropdown, NSwitch, NPopover } from 'naive-ui';
 import CGrid from '../../../packages/grid';
 import vexutils from '../../../src/utils/vexutils';
 import { handleTableHeight, setTableConfig, handleGroupColums, treeToList, checkMethod, setTreeGroupTitle, handleName, generateEditRender, handlerInitSearchItem, getEvaluate, getMapVal, getCandidateComponents, getageShowType, isLink, showFilter, reScrollFilterWrap, hideFilterWrap, mergeConObjFn, setDefaultFormData, handleImgArr, handleImgSrc, modalDetailImage, handleQrCodeContent, getInlineEditBtn, isCopy, setVisibleCheckAllWrap, handleTableImageSize, visibleMethod, getRowStyle, getFooterGroup, flattenRow, intersectRow, removeCheckedDisabledRows } from './utils.js';
-import './components/input-button.js';
-import './components/separate.js';
+import InputButtonScript from './components/input-button.js';
+import Separate from './components/separate.js';
 import xb_big from '../../../src/assets/img/xb_big';
 import qr from '../../../src/assets/img/qr';
-import script$1 from './components/NoData.vue_vue_type_script_setup_true_lang.js';
-import script$2 from './components/input-button.vue_vue_type_script_setup_true_lang.js';
-import script$3 from './components/separate.vue_vue_type_script_setup_true_lang.js';
 
 const _hoisted_1 = {
   key: 0,
@@ -42,7 +39,7 @@ const _hoisted_6 = {
 function _isSlot(s) {
   return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
 }
-var script = /* @__PURE__ */ defineComponent({
+var _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "BigTable",
   props: bigTableProps,
   emits: bigTableEmits,
@@ -55,7 +52,7 @@ var script = /* @__PURE__ */ defineComponent({
     let _beforeSearchConvert = [];
     let addInlineEditPrimaryKey = "";
     const GROUP_TITLE_KEY = "group-show-title";
-    const InputButton = script$2;
+    const InputButton = InputButtonScript;
     const $message = useMessage();
     const xGrid = ref({});
     const copyState = vexutils.clone(bigTableState, true);
@@ -472,7 +469,7 @@ var script = /* @__PURE__ */ defineComponent({
               if (!isEdit || item.columnName === "operatorColumn" || !item.isEdit) {
                 return formatter(params, item);
               } else if (item.formType === "separate") {
-                const SeparateComponent = script$3;
+                const SeparateComponent = Separate;
                 return createVNode(SeparateComponent, {
                   "row": params.row,
                   "col": item
@@ -2362,7 +2359,7 @@ var script = /* @__PURE__ */ defineComponent({
       }), {
         empty: withCtx(() => [state.isShowEmpty ? renderSlot(_ctx.$slots, "empty", {
           key: 0
-        }, () => [createVNode(script$1, {
+        }, () => [createVNode(NoData, {
           "no-data-img": props.emptyItems.noDataImg,
           "no-data-tip": props.emptyItems.noDataTip,
           "show-img": !props.isNestTable
@@ -2424,4 +2421,4 @@ var script = /* @__PURE__ */ defineComponent({
   }
 });
 
-export { script as default };
+export { _sfc_main as default };