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

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

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

@@ -1,193 +0,0 @@
-import { isFn } from './checkers.js';
-import { ArraySet } from './array.js';
-import { RawReactionsMap, ReactionStack, BatchCount, PendingReactions, BatchEndpoints, PendingScopeReactions, ObserverListeners, BatchScope, UntrackCount } from './environment.js';
-
-var ITERATION_KEY = Symbol('iteration key');
-var addRawReactionsMap = function (target, key, reaction) {
-    var reactionsMap = RawReactionsMap.get(target);
-    if (reactionsMap) {
-        var reactions = reactionsMap.get(key);
-        if (reactions) {
-            reactions.add(reaction);
-        }
-        else {
-            reactionsMap.set(key, new ArraySet([reaction]));
-        }
-        return reactionsMap;
-    }
-    else {
-        var reactionsMap_1 = new Map([
-            [key, new ArraySet([reaction])],
-        ]);
-        RawReactionsMap.set(target, reactionsMap_1);
-        return reactionsMap_1;
-    }
-};
-var addReactionsMapToReaction = function (reaction, reactionsMap) {
-    var bindSet = reaction._reactionsSet;
-    if (bindSet) {
-        bindSet.add(reactionsMap);
-    }
-    else {
-        reaction._reactionsSet = new ArraySet([reactionsMap]);
-    }
-    return bindSet;
-};
-var getReactionsFromTargetKey = function (target, key) {
-    var reactionsMap = RawReactionsMap.get(target);
-    var reactions = [];
-    if (reactionsMap) {
-        var map = reactionsMap.get(key);
-        if (map) {
-            map.forEach(function (reaction) {
-                if (reactions.indexOf(reaction) === -1) {
-                    reactions.push(reaction);
-                }
-            });
-        }
-    }
-    return reactions;
-};
-var runReactions = function (target, key) {
-    var reactions = getReactionsFromTargetKey(target, key);
-    var prevUntrackCount = UntrackCount.value;
-    UntrackCount.value = 0;
-    for (var i = 0, len = reactions.length; i < len; i++) {
-        var reaction = reactions[i];
-        if (reaction._isComputed) {
-            reaction._scheduler(reaction);
-        }
-        else if (isScopeBatching()) {
-            PendingScopeReactions.add(reaction);
-        }
-        else if (isBatching()) {
-            PendingReactions.add(reaction);
-        }
-        else {
-            if (isFn(reaction._scheduler)) {
-                reaction._scheduler(reaction);
-            }
-            else {
-                reaction();
-            }
-        }
-    }
-    UntrackCount.value = prevUntrackCount;
-};
-var notifyObservers = function (operation) {
-    ObserverListeners.forEach(function (fn) { return fn(operation); });
-};
-var bindTargetKeyWithCurrentReaction = function (operation) {
-    var key = operation.key, type = operation.type, target = operation.target;
-    if (type === 'iterate') {
-        key = ITERATION_KEY;
-    }
-    var current = ReactionStack[ReactionStack.length - 1];
-    if (isUntracking())
-        return;
-    if (current) {
-        addReactionsMapToReaction(current, addRawReactionsMap(target, key, current));
-    }
-};
-var bindComputedReactions = function (reaction) {
-    if (isFn(reaction)) {
-        var current = ReactionStack[ReactionStack.length - 1];
-        if (current) {
-            var computes = current._computesSet;
-            if (computes) {
-                computes.add(reaction);
-            }
-            else {
-                current._computesSet = new ArraySet([reaction]);
-            }
-        }
-    }
-};
-var runReactionsFromTargetKey = function (operation) {
-    var key = operation.key, type = operation.type, target = operation.target, oldTarget = operation.oldTarget;
-    batchStart();
-    notifyObservers(operation);
-    if (type === 'clear') {
-        oldTarget.forEach(function (_, key) {
-            runReactions(target, key);
-        });
-    }
-    else {
-        runReactions(target, key);
-    }
-    if (type === 'add' || type === 'delete' || type === 'clear') {
-        var newKey = Array.isArray(target) ? 'length' : ITERATION_KEY;
-        runReactions(target, newKey);
-    }
-    batchEnd();
-};
-var hasRunningReaction = function () {
-    return ReactionStack.length > 0;
-};
-var releaseBindingReactions = function (reaction) {
-    var _a;
-    (_a = reaction._reactionsSet) === null || _a === void 0 ? void 0 : _a.forEach(function (reactionsMap) {
-        reactionsMap.forEach(function (reactions) {
-            reactions.delete(reaction);
-        });
-    });
-    PendingReactions.delete(reaction);
-    PendingScopeReactions.delete(reaction);
-    delete reaction._reactionsSet;
-};
-var batchStart = function () {
-    BatchCount.value++;
-};
-var batchEnd = function () {
-    BatchCount.value--;
-    if (BatchCount.value === 0) {
-        var prevUntrackCount = UntrackCount.value;
-        UntrackCount.value = 0;
-        executePendingReactions();
-        executeBatchEndpoints();
-        UntrackCount.value = prevUntrackCount;
-    }
-};
-var batchScopeStart = function () {
-    BatchScope.value = true;
-};
-var batchScopeEnd = function () {
-    var prevUntrackCount = UntrackCount.value;
-    BatchScope.value = false;
-    UntrackCount.value = 0;
-    PendingScopeReactions.batchDelete(function (reaction) {
-        if (isFn(reaction._scheduler)) {
-            reaction._scheduler(reaction);
-        }
-        else {
-            reaction();
-        }
-    });
-    UntrackCount.value = prevUntrackCount;
-};
-var untrackStart = function () {
-    UntrackCount.value++;
-};
-var untrackEnd = function () {
-    UntrackCount.value--;
-};
-var isBatching = function () { return BatchCount.value > 0; };
-var isScopeBatching = function () { return BatchScope.value; };
-var isUntracking = function () { return UntrackCount.value > 0; };
-var executePendingReactions = function () {
-    PendingReactions.batchDelete(function (reaction) {
-        if (isFn(reaction._scheduler)) {
-            reaction._scheduler(reaction);
-        }
-        else {
-            reaction();
-        }
-    });
-};
-var executeBatchEndpoints = function () {
-    BatchEndpoints.batchDelete(function (callback) {
-        callback();
-    });
-};
-
-export { batchEnd, batchScopeEnd, batchScopeStart, batchStart, bindComputedReactions, bindTargetKeyWithCurrentReaction, executeBatchEndpoints, executePendingReactions, hasRunningReaction, isBatching, isScopeBatching, isUntracking, releaseBindingReactions, runReactionsFromTargetKey, untrackEnd, untrackStart };

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

@@ -1,67 +0,0 @@
-import { ProxyRaw, RawNode } from './environment.js';
-
-var DataNode = /** @class */ (function () {
-    function DataNode(target, key, value) {
-        this.target = target;
-        this.key = key;
-        this.value = value;
-    }
-    Object.defineProperty(DataNode.prototype, "path", {
-        get: function () {
-            if (!this.parent)
-                return this.key ? [this.key] : [];
-            return this.parent.path.concat(this.key);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DataNode.prototype, "targetRaw", {
-        get: function () {
-            return ProxyRaw.get(this.target) || this.target;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(DataNode.prototype, "parent", {
-        get: function () {
-            if (!this.target)
-                return;
-            return getDataNode(this.targetRaw);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    DataNode.prototype.isEqual = function (node) {
-        if (this.key) {
-            return node.targetRaw === this.targetRaw && node.key === this.key;
-        }
-        return node.value === this.value;
-    };
-    DataNode.prototype.contains = function (node) {
-        if (node === this)
-            return true;
-        var parent = node.parent;
-        while (!!parent) {
-            if (this.isEqual(parent))
-                return true;
-            parent = parent.parent;
-        }
-        return false;
-    };
-    return DataNode;
-}());
-var getDataNode = function (raw) {
-    return RawNode.get(raw);
-};
-var setDataNode = function (raw, node) {
-    RawNode.set(raw, node);
-};
-var buildDataTree = function (target, key, value) {
-    var raw = ProxyRaw.get(value) || value;
-    var currentNode = getDataNode(raw);
-    if (currentNode)
-        return currentNode;
-    setDataNode(raw, new DataNode(target, key, value));
-};
-
-export { DataNode, buildDataTree, getDataNode, setDataNode };

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

@@ -1,6 +0,0 @@
-import { createBoundaryFunction } from './internals.js';
-import { untrackEnd, untrackStart } from './reaction.js';
-
-var untracked = createBoundaryFunction(untrackStart, untrackEnd);
-
-export { untracked };