cnhis-design-vue 3.1.14-beta.9 → 3.1.15-beta.1

package/es/_virtual/plugin-vue_export-helper.js

@@ -0,0 +1,9 @@
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+export { _export_sfc as default };

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

@@ -0,0 +1,22 @@
+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 ContextType = function (flag, props) {
+    return __assign({ flag: flag }, props);
+};
+var bracketContext = ContextType('[]');
+var bracketArrayContext = ContextType('[\\d]');
+var bracketDContext = ContextType('[[]]');
+var parenContext = ContextType('()');
+var braceContext = ContextType('{}');
+var destructorContext = ContextType('{x}');
+
+export { braceContext, bracketArrayContext, bracketContext, bracketDContext, destructorContext, parenContext };

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

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