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

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,265 @@
+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

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,193 @@
+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 };