cnhis-design-vue 3.1.40-beta.4 → 3.1.40-beta.6

package/es/node_modules/@formily/reactive/esm/annotations/shallow.js

@@ -1,43 +0,0 @@
-import { createAnnotation, createObservable } from '../internals.js';
-import { bindTargetKeyWithCurrentReaction, runReactionsFromTargetKey } from '../reaction.js';
-
-var shallow = createAnnotation(function (_a) {
-    var target = _a.target, key = _a.key, value = _a.value;
-    var store = {
-        value: createObservable(target, key, target ? target[key] : value, true),
-    };
-    function get() {
-        bindTargetKeyWithCurrentReaction({
-            target: target,
-            key: key,
-            type: 'get',
-        });
-        return store.value;
-    }
-    function set(value) {
-        var oldValue = store.value;
-        value = createObservable(target, key, value, true);
-        store.value = value;
-        if (oldValue === value)
-            return;
-        runReactionsFromTargetKey({
-            target: target,
-            key: key,
-            type: 'set',
-            oldValue: oldValue,
-            value: value,
-        });
-    }
-    if (target) {
-        Object.defineProperty(target, key, {
-            set: set,
-            get: get,
-            enumerable: true,
-            configurable: false,
-        });
-        return target;
-    }
-    return store.value;
-});
-
-export { shallow };

package/es/node_modules/@formily/reactive/esm/array.js

@@ -1,49 +0,0 @@
-var ArraySet = /** @class */ (function () {
-    function ArraySet(value) {
-        if (value === void 0) { value = []; }
-        this.forEachIndex = 0;
-        this.value = value;
-    }
-    ArraySet.prototype.add = function (item) {
-        if (!this.has(item)) {
-            this.value.push(item);
-        }
-    };
-    ArraySet.prototype.has = function (item) {
-        return this.value.indexOf(item) > -1;
-    };
-    ArraySet.prototype.delete = function (item) {
-        var findIndex = this.value.indexOf(item);
-        if (findIndex > -1) {
-            this.value.splice(findIndex, 1);
-            if (findIndex <= this.forEachIndex) {
-                this.forEachIndex -= 1;
-            }
-        }
-    };
-    ArraySet.prototype.forEach = function (callback) {
-        if (this.value.length === 0)
-            return;
-        this.forEachIndex = 0;
-        for (; this.forEachIndex < this.value.length; this.forEachIndex++) {
-            callback(this.value[this.forEachIndex]);
-        }
-    };
-    ArraySet.prototype.batchDelete = function (callback) {
-        if (this.value.length === 0)
-            return;
-        this.forEachIndex = 0;
-        for (; this.forEachIndex < this.value.length; this.forEachIndex++) {
-            var value = this.value[this.forEachIndex];
-            this.value.splice(this.forEachIndex, 1);
-            this.forEachIndex--;
-            callback(value);
-        }
-    };
-    ArraySet.prototype.clear = function () {
-        this.value.length = 0;
-    };
-    return ArraySet;
-}());
-
-export { ArraySet };

package/es/node_modules/@formily/reactive/esm/autorun.js

@@ -1,14 +0,0 @@
-import './array.js';
-import './environment.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);
-};

package/es/node_modules/@formily/reactive/esm/batch.js

@@ -1,19 +0,0 @@
-import { batchEnd, batchStart, batchScopeEnd, batchScopeStart } from './reaction.js';
-import { BatchCount, BatchEndpoints } from './environment.js';
-import { createBoundaryAnnotation } from './internals.js';
-import { isFn } from './checkers.js';
-
-var batch = createBoundaryAnnotation(batchStart, batchEnd);
-batch.scope = createBoundaryAnnotation(batchScopeStart, batchScopeEnd);
-batch.endpoint = function (callback) {
-    if (!isFn(callback))
-        return;
-    if (BatchCount.value === 0) {
-        callback();
-    }
-    else {
-        BatchEndpoints.add(callback);
-    }
-};
-
-export { batch };

package/es/node_modules/@formily/reactive/esm/checkers.js

@@ -1,25 +0,0 @@
-var toString = Object.prototype.toString;
-var isMap = function (val) {
-    return val && val instanceof Map;
-};
-var isSet = function (val) { return val && val instanceof Set; };
-var isWeakMap = function (val) {
-    return val && val instanceof WeakMap;
-};
-var isWeakSet = function (val) {
-    return val && val instanceof WeakSet;
-};
-var isFn = function (val) { return typeof val === 'function'; };
-var isArr = Array.isArray;
-var isPlainObj = function (val) {
-    return toString.call(val) === '[object Object]';
-};
-var isValid = function (val) { return val !== null && val !== undefined; };
-var isCollectionType = function (target) {
-    return (isMap(target) || isWeakMap(target) || isSet(target) || isWeakSet(target));
-};
-var isNormalType = function (target) {
-    return isPlainObj(target) || isArr(target);
-};
-
-export { isArr, isCollectionType, isFn, isMap, isNormalType, isPlainObj, isSet, isValid, isWeakMap, isWeakSet };

package/es/node_modules/@formily/reactive/esm/environment.js

@@ -1,18 +0,0 @@
-import { ArraySet } from './array.js';
-
-var ProxyRaw = new WeakMap();
-var RawProxy = new WeakMap();
-var RawShallowProxy = new WeakMap();
-var RawNode = new WeakMap();
-var RawReactionsMap = new WeakMap();
-var ReactionStack = [];
-var BatchCount = { value: 0 };
-var UntrackCount = { value: 0 };
-var BatchScope = { value: false };
-var PendingReactions = new ArraySet();
-var PendingScopeReactions = new ArraySet();
-var BatchEndpoints = new ArraySet();
-var MakeObservableSymbol = Symbol('MakeObservableSymbol');
-var ObserverListeners = new ArraySet();
-
-export { BatchCount, BatchEndpoints, BatchScope, MakeObservableSymbol, ObserverListeners, PendingReactions, PendingScopeReactions, ProxyRaw, RawNode, RawProxy, RawReactionsMap, RawShallowProxy, ReactionStack, UntrackCount };

package/es/node_modules/@formily/reactive/esm/externals.js

@@ -1,44 +0,0 @@
-import { isValid, isArr, isPlainObj, isFn, isMap, isWeakMap, isSet, isWeakSet } from './checkers.js';
-import { ProxyRaw } from './environment.js';
-import './tree.js';
-
-var RAW_TYPE = Symbol('RAW_TYPE');
-var OBSERVABLE_TYPE = Symbol('OBSERVABLE_TYPE');
-var isObservable = function (target) {
-    return ProxyRaw.has(target);
-};
-var isSupportObservable = function (target) {
-    if (!isValid(target))
-        return false;
-    if (isArr(target))
-        return true;
-    if (isPlainObj(target)) {
-        if (target[RAW_TYPE]) {
-            return false;
-        }
-        if (target[OBSERVABLE_TYPE]) {
-            return true;
-        }
-        if ('$$typeof' in target && '_owner' in target) {
-            return false;
-        }
-        if (target['_isAMomentObject']) {
-            return false;
-        }
-        if (target['_isJSONSchemaObject']) {
-            return false;
-        }
-        if (isFn(target['toJS'])) {
-            return false;
-        }
-        if (isFn(target['toJSON'])) {
-            return false;
-        }
-        return true;
-    }
-    if (isMap(target) || isWeakMap(target) || isSet(target) || isWeakSet(target))
-        return true;
-    return false;
-};
-
-export { isObservable, isSupportObservable };

package/es/node_modules/@formily/reactive/esm/handlers.js

@@ -1,265 +0,0 @@
-import { bindTargetKeyWithCurrentReaction, runReactionsFromTargetKey } from './reaction.js';
-import { ProxyRaw, RawProxy } from './environment.js';
-import { isObservable, isSupportObservable } from './externals.js';
-import { createObservable } from './internals.js';
-
-var __read = (undefined && undefined.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var _a;
-var wellKnownSymbols = new Set(Object.getOwnPropertyNames(Symbol)
-    .map(function (key) { return Symbol[key]; })
-    .filter(function (value) { return typeof value === 'symbol'; }));
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-function findObservable(target, key, value) {
-    var observableObj = RawProxy.get(value);
-    if (observableObj) {
-        return observableObj;
-    }
-    if (!isObservable(value) && isSupportObservable(value)) {
-        return createObservable(target, key, value);
-    }
-    return value;
-}
-function patchIterator(target, key, iterator, isEntries) {
-    var originalNext = iterator.next;
-    iterator.next = function () {
-        var _a = originalNext.call(iterator), done = _a.done, value = _a.value;
-        if (!done) {
-            if (isEntries) {
-                value[1] = findObservable(target, key, value[1]);
-            }
-            else {
-                value = findObservable(target, key, value);
-            }
-        }
-        return { done: done, value: value };
-    };
-    return iterator;
-}
-var instrumentations = (_a = {
-        has: function (key) {
-            var target = ProxyRaw.get(this);
-            var proto = Reflect.getPrototypeOf(this);
-            bindTargetKeyWithCurrentReaction({ target: target, key: key, type: 'has' });
-            return proto.has.apply(target, arguments);
-        },
-        get: function (key) {
-            var target = ProxyRaw.get(this);
-            var proto = Reflect.getPrototypeOf(this);
-            bindTargetKeyWithCurrentReaction({ target: target, key: key, type: 'get' });
-            return findObservable(target, key, proto.get.apply(target, arguments));
-        },
-        add: function (key) {
-            var target = ProxyRaw.get(this);
-            var proto = Reflect.getPrototypeOf(this);
-            var hadKey = proto.has.call(target, key);
-            // forward the operation before queueing reactions
-            var result = proto.add.apply(target, arguments);
-            if (!hadKey) {
-                runReactionsFromTargetKey({ target: target, key: key, value: key, type: 'add' });
-            }
-            return result;
-        },
-        set: function (key, value) {
-            var target = ProxyRaw.get(this);
-            var proto = Reflect.getPrototypeOf(this);
-            var hadKey = proto.has.call(target, key);
-            var oldValue = proto.get.call(target, key);
-            // forward the operation before queueing reactions
-            var result = proto.set.apply(target, arguments);
-            if (!hadKey) {
-                runReactionsFromTargetKey({ target: target, key: key, value: value, type: 'add' });
-            }
-            else if (value !== oldValue) {
-                runReactionsFromTargetKey({ target: target, key: key, value: value, oldValue: oldValue, type: 'set' });
-            }
-            return result;
-        },
-        delete: function (key) {
-            var target = ProxyRaw.get(this);
-            var proto = Reflect.getPrototypeOf(this);
-            var hadKey = proto.has.call(target, key);
-            var oldValue = proto.get ? proto.get.call(target, key) : undefined;
-            // forward the operation before queueing reactions
-            var result = proto.delete.apply(target, arguments);
-            if (hadKey) {
-                runReactionsFromTargetKey({ target: target, key: key, oldValue: oldValue, type: 'delete' });
-            }
-            return result;
-        },
-        clear: function () {
-            var target = ProxyRaw.get(this);
-            var proto = Reflect.getPrototypeOf(this);
-            var hadItems = target.size !== 0;
-            var oldTarget = target instanceof Map ? new Map(target) : new Set(target);
-            // forward the operation before queueing reactions
-            var result = proto.clear.apply(target, arguments);
-            if (hadItems) {
-                runReactionsFromTargetKey({ target: target, oldTarget: oldTarget, type: 'clear' });
-            }
-            return result;
-        },
-        forEach: function (cb) {
-            var _a;
-            var args = [];
-            for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-            }
-            var target = ProxyRaw.get(this);
-            var proto = Reflect.getPrototypeOf(this);
-            bindTargetKeyWithCurrentReaction({ target: target, type: 'iterate' });
-            // swap out the raw values with their observable pairs
-            // before passing them to the callback
-            var wrappedCb = function (value, key) {
-                var args = [];
-                for (var _i = 2; _i < arguments.length; _i++) {
-                    args[_i - 2] = arguments[_i];
-                }
-                return cb.apply(void 0, __spreadArray([findObservable(target, key, value), key], __read(args), false));
-            };
-            return (_a = proto.forEach).call.apply(_a, __spreadArray([target, wrappedCb], __read(args), false));
-        },
-        keys: function () {
-            var target = ProxyRaw.get(this);
-            var proto = Reflect.getPrototypeOf(this);
-            bindTargetKeyWithCurrentReaction({ target: target, type: 'iterate' });
-            return proto.keys.apply(target, arguments);
-        },
-        values: function () {
-            var target = ProxyRaw.get(this);
-            var proto = Reflect.getPrototypeOf(this);
-            bindTargetKeyWithCurrentReaction({ target: target, type: 'iterate' });
-            var iterator = proto.values.apply(target, arguments);
-            return patchIterator(target, '', iterator, false);
-        },
-        entries: function () {
-            var target = ProxyRaw.get(this);
-            var proto = Reflect.getPrototypeOf(this);
-            bindTargetKeyWithCurrentReaction({ target: target, type: 'iterate' });
-            var iterator = proto.entries.apply(target, arguments);
-            return patchIterator(target, '', iterator, true);
-        }
-    },
-    _a[Symbol.iterator] = function () {
-        var target = ProxyRaw.get(this);
-        var proto = Reflect.getPrototypeOf(this);
-        bindTargetKeyWithCurrentReaction({ target: target, type: 'iterate' });
-        var iterator = proto[Symbol.iterator].apply(target, arguments);
-        return patchIterator(target, '', iterator, target instanceof Map);
-    },
-    Object.defineProperty(_a, "size", {
-        get: function () {
-            var target = ProxyRaw.get(this);
-            var proto = Reflect.getPrototypeOf(this);
-            bindTargetKeyWithCurrentReaction({ target: target, type: 'iterate' });
-            return Reflect.get(proto, 'size', target);
-        },
-        enumerable: false,
-        configurable: true
-    }),
-    _a);
-var collectionHandlers = {
-    get: function (target, key, receiver) {
-        // instrument methods and property accessors to be reactive
-        target = hasOwnProperty.call(instrumentations, key)
-            ? instrumentations
-            : target;
-        return Reflect.get(target, key, receiver);
-    },
-};
-var baseHandlers = {
-    get: function (target, key, receiver) {
-        if (!key)
-            return;
-        var result = target[key]; // use Reflect.get is too slow
-        if (typeof key === 'symbol' && wellKnownSymbols.has(key)) {
-            return result;
-        }
-        bindTargetKeyWithCurrentReaction({ target: target, key: key, receiver: receiver, type: 'get' });
-        var observableResult = RawProxy.get(result);
-        if (observableResult) {
-            return observableResult;
-        }
-        if (!isObservable(result) && isSupportObservable(result)) {
-            var descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-            if (!descriptor ||
-                !(descriptor.writable === false && descriptor.configurable === false)) {
-                return createObservable(target, key, result);
-            }
-        }
-        return result;
-    },
-    has: function (target, key) {
-        var result = Reflect.has(target, key);
-        bindTargetKeyWithCurrentReaction({ target: target, key: key, type: 'has' });
-        return result;
-    },
-    ownKeys: function (target) {
-        var keys = Reflect.ownKeys(target);
-        bindTargetKeyWithCurrentReaction({ target: target, type: 'iterate' });
-        return keys;
-    },
-    set: function (target, key, value, receiver) {
-        var hadKey = hasOwnProperty.call(target, key);
-        var newValue = createObservable(target, key, value);
-        var oldValue = target[key];
-        target[key] = newValue; // use Reflect.set is too slow
-        if (!hadKey) {
-            runReactionsFromTargetKey({
-                target: target,
-                key: key,
-                value: newValue,
-                oldValue: oldValue,
-                receiver: receiver,
-                type: 'add',
-            });
-        }
-        else if (value !== oldValue) {
-            runReactionsFromTargetKey({
-                target: target,
-                key: key,
-                value: newValue,
-                oldValue: oldValue,
-                receiver: receiver,
-                type: 'set',
-            });
-        }
-        return true;
-    },
-    deleteProperty: function (target, key) {
-        var oldValue = target[key];
-        delete target[key];
-        runReactionsFromTargetKey({
-            target: target,
-            key: key,
-            oldValue: oldValue,
-            type: 'delete',
-        });
-        return true;
-    },
-};
-
-export { baseHandlers, collectionHandlers };

package/es/node_modules/@formily/reactive/esm/internals.js

@@ -1,114 +0,0 @@
-import { isNormalType, isCollectionType, isFn } from './checkers.js';
-import { MakeObservableSymbol, ProxyRaw, RawShallowProxy, RawProxy } from './environment.js';
-import { baseHandlers, collectionHandlers } from './handlers.js';
-import { getDataNode, buildDataTree } from './tree.js';
-import { isSupportObservable } from './externals.js';
-
-var createNormalProxy = function (target, shallow) {
-    var proxy = new Proxy(target, baseHandlers);
-    ProxyRaw.set(proxy, target);
-    if (shallow) {
-        RawShallowProxy.set(target, proxy);
-    }
-    else {
-        RawProxy.set(target, proxy);
-    }
-    return proxy;
-};
-var createCollectionProxy = function (target, shallow) {
-    var proxy = new Proxy(target, collectionHandlers);
-    ProxyRaw.set(proxy, target);
-    if (shallow) {
-        RawShallowProxy.set(target, proxy);
-    }
-    else {
-        RawProxy.set(target, proxy);
-    }
-    return proxy;
-};
-var createShallowProxy = function (target) {
-    if (isNormalType(target))
-        return createNormalProxy(target, true);
-    if (isCollectionType(target))
-        return createCollectionProxy(target, true);
-    return target;
-};
-var createObservable = function (target, key, value, shallow) {
-    if (typeof value !== 'object')
-        return value;
-    var raw = ProxyRaw.get(value);
-    if (!!raw) {
-        var node = getDataNode(raw);
-        if (!node.target)
-            node.target = target;
-        node.key = key;
-        return value;
-    }
-    if (!isSupportObservable(value))
-        return value;
-    if (target) {
-        var parentRaw = ProxyRaw.get(target) || target;
-        var isShallowParent = RawShallowProxy.get(parentRaw);
-        if (isShallowParent)
-            return value;
-    }
-    buildDataTree(target, key, value);
-    if (shallow)
-        return createShallowProxy(value);
-    if (isNormalType(value))
-        return createNormalProxy(value);
-    if (isCollectionType(value))
-        return createCollectionProxy(value);
-    return value;
-};
-var createAnnotation = function (maker) {
-    var annotation = function (target) {
-        return maker({ value: target });
-    };
-    if (isFn(maker)) {
-        annotation[MakeObservableSymbol] = maker;
-    }
-    return annotation;
-};
-var createBoundaryFunction = function (start, end) {
-    function boundary(fn) {
-        var results;
-        try {
-            start();
-            if (isFn(fn)) {
-                results = fn();
-            }
-        }
-        finally {
-            end();
-        }
-        return results;
-    }
-    boundary.bound = createBindFunction(boundary);
-    return boundary;
-};
-var createBindFunction = function (boundary) {
-    function bind(callback, context) {
-        return (function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return boundary(function () { return callback.apply(context, args); });
-        });
-    }
-    return bind;
-};
-var createBoundaryAnnotation = function (start, end) {
-    var boundary = createBoundaryFunction(start, end);
-    var annotation = createAnnotation(function (_a) {
-        var target = _a.target, key = _a.key;
-        target[key] = boundary.bound(target[key], target);
-        return target;
-    });
-    boundary[MakeObservableSymbol] = annotation;
-    boundary.bound[MakeObservableSymbol] = annotation;
-    return boundary;
-};
-
-export { createAnnotation, createBindFunction, createBoundaryAnnotation, createBoundaryFunction, createObservable };

package/es/node_modules/@formily/reactive/esm/observable.js

@@ -1,19 +0,0 @@
-import { observable as observable$1 } from './annotations/observable.js';
-import { box } from './annotations/box.js';
-import { ref } from './annotations/ref.js';
-import { shallow } from './annotations/shallow.js';
-import { computed } from './annotations/computed.js';
-import { MakeObservableSymbol } from './environment.js';
-import { createObservable } from './internals.js';
-
-function observable(target) {
-    return createObservable(null, null, target);
-}
-observable.box = box;
-observable.ref = ref;
-observable.deep = observable$1;
-observable.shallow = shallow;
-observable.computed = computed;
-observable[MakeObservableSymbol] = observable$1;
-
-export { observable };