fineui是帆软报表和BI产品线所使用的前端框架。
 
 
 

2035 lines
60 KiB

(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Fix = {}));
}(this, (function (exports) { 'use strict';
function _typeof(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function (obj) {
return typeof obj;
};
} else {
_typeof = function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
}
return _typeof(obj);
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
var EMPTY_OBJ = Object.freeze({});
Object.freeze([]);
var extend = Object.assign;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var hasOwn = function hasOwn(val, key) {
return hasOwnProperty.call(val, key);
};
var isArray = Array.isArray;
var isMap$1 = function isMap(val) {
return toTypeString$1(val) === "[object Map]";
};
var isFunction = function isFunction(val) {
return typeof val === "function";
};
var isString = function isString(val) {
return typeof val === "string";
};
var isSymbol = function isSymbol(val) {
return _typeof(val) === "symbol";
};
var isObject = function isObject(val) {
return val !== null && _typeof(val) === "object";
};
var objectToString$1 = Object.prototype.toString;
var toTypeString$1 = function toTypeString(value) {
return objectToString$1.call(value);
};
var toRawType = function toRawType(value) {
return (// extract "RawType" from strings like "[object RawType]"
toTypeString$1(value).slice(8, -1)
);
};
var isIntegerKey = function isIntegerKey(key) {
return isString(key) && key !== "NaN" && key[0] !== "-" && "".concat(parseInt(key, 10)) === key;
};
var cacheStringFunction = function cacheStringFunction(fn) {
var cache = Object.create(null);
return function (str) {
var hit = cache[str];
return hit || (cache[str] = fn(str));
};
};
/**
* @private
*/
var capitalize = cacheStringFunction(function (str) {
return str.charAt(0).toUpperCase() + str.slice(1);
}); // compare whether a value has changed, accounting for NaN.
var hasChanged$1 = function hasChanged(value, oldValue) {
return value !== oldValue && (value === value || oldValue === oldValue);
};
var targetMap = new WeakMap();
var effectStack = [];
var activeEffect;
var ITERATE_KEY = Symbol("iterate");
var MAP_KEY_ITERATE_KEY = Symbol("Map key iterate");
function isEffect(fn) {
return fn && fn._isEffect === true;
}
function effect(fn) {
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EMPTY_OBJ;
if (isEffect(fn)) {
fn = fn.raw;
}
var effect = createReactiveEffect(fn, options);
if (!options.lazy) {
effect();
}
return effect;
}
function stop(effect) {
if (effect.active) {
cleanup(effect);
if (effect.options.onStop) {
effect.options.onStop();
}
effect.active = false;
}
}
var uid$1 = 0;
function createReactiveEffect(fn, options) {
var effect = function reactiveEffect() {
if (!effect.active) {
return options.scheduler ? undefined : fn();
}
if (!effectStack.includes(effect)) {
cleanup(effect);
try {
enableTracking();
effectStack.push(effect);
activeEffect = effect;
return fn();
} finally {
effectStack.pop();
resetTracking();
activeEffect = effectStack[effectStack.length - 1];
}
}
};
effect.id = uid$1++;
effect.allowRecurse = !!options.allowRecurse;
effect._isEffect = true;
effect.active = true;
effect.raw = fn;
effect.deps = [];
effect.options = options;
return effect;
}
function cleanup(effect) {
var deps = effect.deps;
if (deps.length) {
for (var i = 0; i < deps.length; i++) {
deps[i].delete(effect);
}
deps.length = 0;
}
}
var shouldTrack = true;
var trackStack = [];
function pauseTracking() {
trackStack.push(shouldTrack);
shouldTrack = false;
}
function enableTracking() {
trackStack.push(shouldTrack);
shouldTrack = true;
}
function resetTracking() {
var last = trackStack.pop();
shouldTrack = last === undefined ? true : last;
}
function track(target, type, key) {
if (!shouldTrack || activeEffect === undefined) {
return;
}
var depsMap = targetMap.get(target);
if (!depsMap) {
targetMap.set(target, depsMap = new Map());
}
var dep = depsMap.get(key);
if (!dep) {
depsMap.set(key, dep = new Set());
}
if (!dep.has(activeEffect)) {
dep.add(activeEffect);
activeEffect.deps.push(dep);
if (activeEffect.options.onTrack) {
activeEffect.options.onTrack({
effect: activeEffect,
target: target,
type: type,
key: key
});
}
}
}
function trigger(target, type, key, newValue, oldValue, oldTarget) {
var depsMap = targetMap.get(target);
if (!depsMap) {
// never been tracked
return;
}
var effects = new Set();
var add = function add(effectsToAdd) {
if (effectsToAdd) {
effectsToAdd.forEach(function (effect) {
if (effect !== activeEffect || effect.allowRecurse) {
effects.add(effect);
}
});
}
};
if (type === "clear"
/* CLEAR */
) {
// collection being cleared
// trigger all effects for target
depsMap.forEach(add);
} else if (key === "length" && isArray(target)) {
depsMap.forEach(function (dep, key) {
if (key === "length" || key >= newValue) {
add(dep);
}
});
} else {
// schedule runs for SET | ADD | DELETE
if (key !== void 0) {
add(depsMap.get(key));
} // also run for iteration key on ADD | DELETE | Map.SET
switch (type) {
case "add"
/* ADD */
:
if (!isArray(target)) {
add(depsMap.get(ITERATE_KEY));
if (isMap$1(target)) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
} else if (isIntegerKey(key)) {
// new index added to array -> length changes
add(depsMap.get("length"));
}
break;
case "delete"
/* DELETE */
:
if (!isArray(target)) {
add(depsMap.get(ITERATE_KEY));
if (isMap$1(target)) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
break;
case "set"
/* SET */
:
if (isMap$1(target)) {
add(depsMap.get(ITERATE_KEY));
}
break;
}
}
var run = function run(effect) {
if (effect.options.onTrigger) {
effect.options.onTrigger({
effect: effect,
target: target,
key: key,
type: type,
newValue: newValue,
oldValue: oldValue,
oldTarget: oldTarget
});
}
if (effect.options.scheduler) {
effect.options.scheduler(effect);
} else {
effect();
}
};
effects.forEach(run);
}
var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map(function (key) {
return Symbol[key];
}).filter(isSymbol));
var get = /* #__PURE__*/createGetter();
var shallowGet = /* #__PURE__*/createGetter(false, true);
var readonlyGet = /* #__PURE__*/createGetter(true);
var shallowReadonlyGet = /* #__PURE__*/createGetter(true, true);
var arrayInstrumentations = {};
["includes", "indexOf", "lastIndexOf"].forEach(function (key) {
var method = Array.prototype[key];
arrayInstrumentations[key] = function () {
var arr = toRaw(this);
for (var i = 0, l = this.length; i < l; i++) {
track(arr, "get"
/* GET */
, "".concat(i));
} // we run the method using the original args first (which may be reactive)
for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
args[_key2] = arguments[_key2];
}
var res = method.apply(arr, args);
if (res === -1 || res === false) {
// if that didn't work, run it again using raw values.
return method.apply(arr, args.map(toRaw));
} else {
return res;
}
};
});
["push", "pop", "shift", "unshift", "splice"].forEach(function (key) {
var method = Array.prototype[key];
arrayInstrumentations[key] = function () {
pauseTracking();
for (var _len2 = arguments.length, args = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
args[_key3] = arguments[_key3];
}
var res = method.apply(this, args);
resetTracking();
return res;
};
});
function createGetter() {
var isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
var shallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
return function get(target, key, receiver) {
if (key === "__v_isReactive"
/* IS_REACTIVE */
) {
return !isReadonly;
} else if (key === "__v_isReadonly"
/* IS_READONLY */
) {
return isReadonly;
} else if (key === "__v_raw"
/* RAW */
&& receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {
return target;
}
var targetIsArray = isArray(target);
if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
return Reflect.get(arrayInstrumentations, key, receiver);
}
var res = Reflect.get(target, key, receiver);
if (isSymbol(key) ? builtInSymbols.has(key) : key === "__proto__" || key === "__v_isRef") {
return res;
}
if (!isReadonly) {
track(target, "get"
/* GET */
, key);
}
if (shallow) {
return res;
}
if (isRef(res)) {
// ref unwrapping - does not apply for Array + integer key.
var shouldUnwrap = !targetIsArray || !isIntegerKey(key);
return shouldUnwrap ? res.value : res;
}
if (isObject(res)) {
// Convert returned value into a proxy as well. we do the isObject check
// here to avoid invalid value warning. Also need to lazy access readonly
// and reactive here to avoid circular dependency.
return isReadonly ? readonly(res) : reactive(res);
}
return res;
};
}
var set$1 = /* #__PURE__*/createSetter();
var shallowSet = /* #__PURE__*/createSetter(true);
function createSetter() {
var shallow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
return function set(target, key, value, receiver) {
var oldValue = target[key];
if (!shallow) {
value = toRaw(value);
if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
}
}
var hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
var result = Reflect.set(target, key, value, receiver); // don't trigger if target is something up in the prototype chain of original
if (target === toRaw(receiver)) {
if (!hadKey) {
trigger(target, "add"
/* ADD */
, key, value);
} else if (hasChanged$1(value, oldValue) || key === "length") {
trigger(target, "set"
/* SET */
, key, value, oldValue);
}
}
return result;
};
}
function deleteProperty(target, key) {
var hadKey = hasOwn(target, key);
var oldValue = target[key];
var result = Reflect.deleteProperty(target, key);
if (result && hadKey) {
trigger(target, "delete"
/* DELETE */
, key, undefined, oldValue);
}
return result;
}
function has$1(target, key) {
var result = Reflect.has(target, key);
if (!isSymbol(key) || !builtInSymbols.has(key)) {
track(target, "has"
/* HAS */
, key);
}
return result;
}
function ownKeys(target) {
track(target, "iterate"
/* ITERATE */
, isArray(target) ? "length" : ITERATE_KEY);
return Reflect.ownKeys(target);
}
var mutableHandlers = {
get: get,
set: set$1,
deleteProperty: deleteProperty,
has: has$1,
ownKeys: ownKeys
};
var readonlyHandlers = {
get: readonlyGet,
set: function set(target, key) {
{
console.warn("Set operation on key \"".concat(String(key), "\" failed: target is readonly."), target);
}
return true;
},
deleteProperty: function deleteProperty(target, key) {
{
console.warn("Delete operation on key \"".concat(String(key), "\" failed: target is readonly."), target);
}
return true;
}
};
extend({}, mutableHandlers, {
get: shallowGet,
set: shallowSet
}); // Props handlers are special in the sense that it should not unwrap top-level
// refs (in order to allow refs to be explicitly passed down), but should
// retain the reactivity of the normal readonly object.
extend({}, readonlyHandlers, {
get: shallowReadonlyGet
});
var toReactive = function toReactive(value) {
return isObject(value) ? reactive(value) : value;
};
var toReadonly = function toReadonly(value) {
return isObject(value) ? readonly(value) : value;
};
var toShallow = function toShallow(value) {
return value;
};
var getProto = function getProto(v) {
return Reflect.getPrototypeOf(v);
};
function get$1(target, key) {
var isReadonly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
var isShallow = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
// #1772: readonly(reactive(Map)) should return readonly + reactive version
// of the value
target = target["__v_raw"
/* RAW */
];
var rawTarget = toRaw(target);
var rawKey = toRaw(key);
if (key !== rawKey) {
!isReadonly && track(rawTarget, "get"
/* GET */
, key);
}
!isReadonly && track(rawTarget, "get"
/* GET */
, rawKey);
var _getProto = getProto(rawTarget),
has = _getProto.has;
var wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
if (has.call(rawTarget, key)) {
return wrap(target.get(key));
} else if (has.call(rawTarget, rawKey)) {
return wrap(target.get(rawKey));
}
}
function has$1$1(key) {
var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var target = this["__v_raw"
/* RAW */
];
var rawTarget = toRaw(target);
var rawKey = toRaw(key);
if (key !== rawKey) {
!isReadonly && track(rawTarget, "has"
/* HAS */
, key);
}
!isReadonly && track(rawTarget, "has"
/* HAS */
, rawKey);
return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
}
function size(target) {
var isReadonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
target = target["__v_raw"
/* RAW */
];
!isReadonly && track(toRaw(target), "iterate"
/* ITERATE */
, ITERATE_KEY);
return Reflect.get(target, "size", target);
}
function add(value) {
value = toRaw(value);
var target = toRaw(this);
var proto = getProto(target);
var hadKey = proto.has.call(target, value);
var result = target.add(value);
if (!hadKey) {
trigger(target, "add"
/* ADD */
, value, value);
}
return result;
}
function set$1$1(key, value) {
value = toRaw(value);
var target = toRaw(this);
var _getProto2 = getProto(target),
has = _getProto2.has,
get = _getProto2.get;
var hadKey = has.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has.call(target, key);
} else {
checkIdentityKeys(target, has, key);
}
var oldValue = get.call(target, key);
var result = target.set(key, value);
if (!hadKey) {
trigger(target, "add"
/* ADD */
, key, value);
} else if (hasChanged$1(value, oldValue) || key === "length") {
trigger(target, "set"
/* SET */
, key, value, oldValue);
}
return result;
}
function deleteEntry(key) {
var target = toRaw(this);
var _getProto3 = getProto(target),
has = _getProto3.has,
get = _getProto3.get;
var hadKey = has.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has.call(target, key);
} else {
checkIdentityKeys(target, has, key);
}
var oldValue = get ? get.call(target, key) : undefined; // forward the operation before queueing reactions
var result = target.delete(key);
if (hadKey) {
trigger(target, "delete"
/* DELETE */
, key, undefined, oldValue);
}
return result;
}
function clear() {
var target = toRaw(this);
var hadItems = target.size !== 0;
var oldTarget = isMap$1(target) ? new Map(target) : new Set(target); // forward the operation before queueing reactions
var result = target.clear();
if (hadItems) {
trigger(target, "clear"
/* CLEAR */
, undefined, undefined, oldTarget);
}
return result;
}
function createForEach(isReadonly, isShallow) {
return function forEach(callback, thisArg) {
var observed = this;
var target = observed["__v_raw"
/* RAW */
];
var rawTarget = toRaw(target);
var wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly && track(rawTarget, "iterate"
/* ITERATE */
, ITERATE_KEY);
return target.forEach(function (value, key) {
return (// important: make sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
callback.call(thisArg, wrap(value), wrap(key), observed)
);
});
};
}
function createIterableMethod(method, isReadonly, isShallow) {
return function () {
var target = this["__v_raw"
/* RAW */
];
var rawTarget = toRaw(target);
var targetIsMap = isMap$1(rawTarget);
var isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
var isKeyOnly = method === "keys" && targetIsMap;
var innerIterator = target[method].apply(target, arguments);
var wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly && track(rawTarget, "iterate"
/* ITERATE */
, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); // return a wrapped iterator which returns observed versions of the
// values emitted from the real iterator
return _defineProperty({
// iterator protocol
next: function next() {
var _innerIterator$next = innerIterator.next(),
value = _innerIterator$next.value,
done = _innerIterator$next.done;
return done ? {
value: value,
done: done
} : {
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
done: done
};
}
}, Symbol.iterator, function () {
return this;
});
};
}
function createReadonlyMethod(type) {
return function () {
{
var key = (arguments.length <= 0 ? undefined : arguments[0]) ? "on key \"".concat(arguments.length <= 0 ? undefined : arguments[0], "\" ") : "";
console.warn("".concat(capitalize(type), " operation ").concat(key, "failed: target is readonly."), toRaw(this));
}
return type === "delete"
/* DELETE */
? false : this;
};
}
var mutableInstrumentations = {
get: function get(key) {
return get$1(this, key);
},
get size() {
return size(this);
},
has: has$1$1,
add: add,
set: set$1$1,
delete: deleteEntry,
clear: clear,
forEach: createForEach(false, false)
};
var shallowInstrumentations = {
get: function get(key) {
return get$1(this, key, false, true);
},
get size() {
return size(this);
},
has: has$1$1,
add: add,
set: set$1$1,
delete: deleteEntry,
clear: clear,
forEach: createForEach(false, true)
};
var readonlyInstrumentations = {
get: function get(key) {
return get$1(this, key, true);
},
get size() {
return size(this, true);
},
has: function has(key) {
return has$1$1.call(this, key, true);
},
add: createReadonlyMethod("add"
/* ADD */
),
set: createReadonlyMethod("set"
/* SET */
),
delete: createReadonlyMethod("delete"
/* DELETE */
),
clear: createReadonlyMethod("clear"
/* CLEAR */
),
forEach: createForEach(true, false)
};
var iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
iteratorMethods.forEach(function (method) {
mutableInstrumentations[method] = createIterableMethod(method, false, false);
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
shallowInstrumentations[method] = createIterableMethod(method, false, true);
});
function createInstrumentationGetter(isReadonly, shallow) {
var instrumentations = shallow ? shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
return function (target, key, receiver) {
if (key === "__v_isReactive"
/* IS_REACTIVE */
) {
return !isReadonly;
} else if (key === "__v_isReadonly"
/* IS_READONLY */
) {
return isReadonly;
} else if (key === "__v_raw"
/* RAW */
) {
return target;
}
return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
};
}
var mutableCollectionHandlers = {
get: createInstrumentationGetter(false, false)
};
var readonlyCollectionHandlers = {
get: createInstrumentationGetter(true, false)
};
function checkIdentityKeys(target, has, key) {
var rawKey = toRaw(key);
if (rawKey !== key && has.call(target, rawKey)) {
var type = toRawType(target);
console.warn("Reactive ".concat(type, " contains both the raw and reactive ") + "versions of the same object".concat(type === "Map" ? " as keys" : "", ", ") + "which can lead to inconsistencies. " + "Avoid differentiating between the raw and reactive versions " + "of an object and only use the reactive version if possible.");
}
}
var reactiveMap = new WeakMap();
var readonlyMap = new WeakMap();
function targetTypeMap(rawType) {
switch (rawType) {
case "Object":
case "Array":
return 1;
case "Map":
case "Set":
case "WeakMap":
case "WeakSet":
return 2;
default:
return 0;
}
}
function getTargetType(value) {
return value["__v_skip"
/* SKIP */
] || !Object.isExtensible(value) ? 0
/* INVALID */
: targetTypeMap(toRawType(value));
}
function reactive(target) {
// if trying to observe a readonly proxy, return the readonly version.
if (target && target["__v_isReadonly"
/* IS_READONLY */
]) {
return target;
}
return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);
} // Return a reactive-copy of the original object, where only the root level
function readonly(target) {
return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);
} // Return a reactive-copy of the original object, where only the root level
function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {
if (!isObject(target)) {
{
console.warn("value cannot be made reactive: ".concat(String(target)));
}
return target;
} // target is already a Proxy, return it.
// exception: calling readonly() on a reactive object
if (target["__v_raw"
/* RAW */
] && !(isReadonly && target["__v_isReactive"
/* IS_REACTIVE */
])) {
return target;
} // target already has corresponding Proxy
var proxyMap = isReadonly ? readonlyMap : reactiveMap;
var existingProxy = proxyMap.get(target);
if (existingProxy) {
return existingProxy;
} // only a whitelist of value types can be observed.
var targetType = getTargetType(target);
if (targetType === 0
/* INVALID */
) {
return target;
}
var proxy = new Proxy(target, targetType === 2
/* COLLECTION */
? collectionHandlers : baseHandlers);
proxyMap.set(target, proxy);
return proxy;
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(value["__v_raw"
/* RAW */
]);
}
return !!(value && value["__v_isReactive"
/* IS_REACTIVE */
]);
}
function isReadonly(value) {
return !!(value && value["__v_isReadonly"
/* IS_READONLY */
]);
}
function toRaw(observed) {
return observed && toRaw(observed["__v_raw"
/* RAW */
]) || observed;
}
function isRef(r) {
return Boolean(r && r.__v_isRef === true);
}
var ComputedRefImpl = /*#__PURE__*/function () {
function ComputedRefImpl(getter, _setter, isReadonly) {
var _this2 = this;
_classCallCheck(this, ComputedRefImpl);
this._setter = _setter;
this._dirty = true;
this.__v_isRef = true;
this.effect = effect(getter, {
lazy: true,
scheduler: function scheduler() {
if (!_this2._dirty) {
_this2._dirty = true;
trigger(toRaw(_this2), "set"
/* SET */
, "value");
}
}
});
this["__v_isReadonly"
/* IS_READONLY */
] = isReadonly;
}
_createClass(ComputedRefImpl, [{
key: "value",
get: function get() {
if (this._dirty) {
this._value = this.effect();
this._dirty = false;
}
track(toRaw(this), "get"
/* GET */
, "value");
return this._value;
},
set: function set(newValue) {
this._setter(newValue);
}
}]);
return ComputedRefImpl;
}();
function computed(getterOrOptions) {
var getter;
var setter;
if (isFunction(getterOrOptions)) {
getter = getterOrOptions;
setter = function setter() {
console.warn("Write operation failed: computed value is readonly");
};
} else {
getter = getterOrOptions.get;
setter = getterOrOptions.set;
}
return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set);
}
function noop() {}
function isNative(Ctor) {
return typeof Ctor === "function" && /native code/.test(Ctor.toString());
}
var isIE = function isIE() {
if (typeof navigator === "undefined") {
return false;
}
return /(msie|trident)/i.test(navigator.userAgent.toLowerCase());
};
var getIEVersion = function getIEVersion() {
var version = 0;
if (typeof navigator === "undefined") {
return false;
}
var agent = navigator.userAgent.toLowerCase();
var v1 = agent.match(/(?:msie\s([\w.]+))/);
var v2 = agent.match(/(?:trident.*rv:([\w.]+))/);
if (v1 && v2 && v1[1] && v2[1]) {
version = Math.max(v1[1] * 1, v2[1] * 1);
} else if (v1 && v1[1]) {
version = v1[1] * 1;
} else if (v2 && v2[1]) {
version = v2[1] * 1;
} else {
version = 0;
}
return version;
};
isIE() && getIEVersion() < 9;
var _toString = Object.prototype.toString;
function isPlainObject(obj) {
return _toString.call(obj) === "[object Object]";
}
var bailRE = /[^\w.$]/;
function parsePath(path) {
if (bailRE.test(path)) {
return;
}
var segments = path.split(".");
return function (obj) {
for (var i = 0; i < segments.length; i++) {
if (!obj) return;
obj = obj[segments[i]];
}
return obj;
};
}
var nextTick = function () {
var callbacks = [];
var pending = false;
var timerFunc;
function nextTickHandler() {
pending = false;
var copies = callbacks.slice(0);
callbacks.length = 0;
for (var i = 0; i < copies.length; i++) {
copies[i]();
}
} // An asynchronous deferring mechanism.
// In pre 2.4, we used to use microtasks (Promise/MutationObserver)
// but microtasks actually has too high a priority and fires in between
// supposedly sequential events (e.g. #4521, #6690) or even between
// bubbling of the same event (#6566). Technically setImmediate should be
// the ideal choice, but it's not available everywhere; and the only polyfill
// that consistently queues the callback after all DOM events triggered in the
// same loop is by using MessageChannel.
/* istanbul ignore if */
if (typeof setImmediate !== "undefined" && isNative(setImmediate)) {
timerFunc = function timerFunc() {
setImmediate(nextTickHandler);
};
} else if (typeof MessageChannel !== "undefined" && (isNative(MessageChannel) || // PhantomJS
MessageChannel.toString() === "[object MessageChannelConstructor]")) {
var channel = new MessageChannel();
var port = channel.port2;
channel.port1.onmessage = nextTickHandler;
timerFunc = function timerFunc() {
port.postMessage(1);
};
} else if (typeof Promise !== "undefined" && isNative(Promise)) {
/* istanbul ignore next */
// use microtask in non-DOM environments, e.g. Weex
var p = Promise.resolve();
timerFunc = function timerFunc() {
p.then(nextTickHandler);
};
} else {
// fallback to setTimeout
timerFunc = function timerFunc() {
setTimeout(nextTickHandler, 0);
};
}
return function queueNextTick(cb, ctx) {
var _resolve;
callbacks.push(function () {
if (cb) {
try {
cb.call(ctx);
} catch (e) {
console.error(e);
}
} else if (_resolve) {
_resolve(ctx);
}
});
if (!pending) {
pending = true;
timerFunc();
} // $flow-disable-line
if (!cb && typeof Promise !== "undefined") {
return new Promise(function (resolve) {
_resolve = resolve;
});
}
};
}();
var mixinInjection = {};
function getMixins(type) {
return mixinInjection[type];
}
function mixin(xtype, cls) {
mixinInjection[xtype] = _.cloneDeep(cls);
}
var queue = [];
var activatedChildren = [];
var has = {};
var waiting = false;
var flushing = false;
var index = 0;
function resetSchedulerState() {
index = queue.length = activatedChildren.length = 0;
has = {};
waiting = flushing = false;
}
function flushSchedulerQueue() {
flushing = true;
var watcher;
var id;
var options; // Sort queue before flush.
// This ensures that:
// 1. Components are updated from parent to child. (because parent is always
// created before the child)
// 2. A component's user watchers are run before its render watcher (because
// user watchers are created before the render watcher)
// 3. If a component is destroyed during a parent component's watcher run,
// its watchers can be skipped.
queue.sort(function (a, b) {
return a.id - b.id;
}); // do not cache length because more watchers might be pushed
// as we run existing watchers
for (index = 0; index < queue.length; index++) {
watcher = queue[index].watcher;
options = queue[index].options;
id = watcher.id;
has[id] = null;
watcher(options);
}
resetSchedulerState();
}
function queueWatcher(watcher, options) {
var id = watcher.id;
if (has[id] == null) {
has[id] = true;
if (!flushing) {
queue.push({
watcher: watcher,
options: options
});
} else {
// if already flushing, splice the watcher based on its id
// if already past its id, it will be run next immediately.
var i = queue.length - 1;
while (i > index && queue[i].watcher.id > watcher.id) {
i--;
}
queue.splice(i + 1, 0, {
watcher: watcher,
options: options
});
} // queue the flush
if (!waiting) {
waiting = true;
nextTick(flushSchedulerQueue);
}
}
}
function innerWatch(source, cb, options) {
if (!_.isFunction(cb)) {
console.warn("`watch(fn, options?)` signature has been moved to a separate API. " + "Use `watchEffect(fn, options?)` instead. `watch` now only " + "supports `watch(source, cb, options?) signature.");
}
return doWatch(source, cb, options);
}
var INITIAL_WATCHER_VALUE = {};
var objectToString = Object.prototype.toString;
var toTypeString = function toTypeString(value) {
return objectToString.call(value);
};
var isMap = function isMap(val) {
return toTypeString(val) === "[object Map]";
};
var isSet = function isSet(val) {
return toTypeString(val) === "[object Set]";
};
var hasChanged = function hasChanged(value, oldValue) {
return value !== oldValue && (value === value || oldValue === oldValue);
};
var uid = 0;
function doWatch(source, cb, options, instance) {
options = options || {};
var _options = options,
immediate = _options.immediate,
deep = _options.deep,
sync = _options.sync,
onTrack = _options.onTrack,
onTrigger = _options.onTrigger;
if (!cb) {
if (immediate !== undefined) {
console.warn("watch() \"immediate\" option is only respected when using the " + "watch(source, callback, options?) signature.");
}
if (deep !== undefined) {
console.warn("watch() \"deep\" option is only respected when using the " + "watch(source, callback, options?) signature.");
}
}
var warnInvalidSource = function warnInvalidSource(s) {
console.warn("Invalid watch source: ", s, "A watch source can only be a getter/effect function, a ref, " + "a reactive object, or an array of these types.");
};
var getter;
var forceTrigger = false;
if (isRef(source)) {
getter = function getter() {
return source.value;
};
forceTrigger = !!source._shallow;
} else if (isReactive(source)) {
getter = function getter() {
return source;
};
deep = true;
} else if (_.isArray(source)) {
getter = function getter() {
return source.map(function (s) {
if (isRef(s)) {
return s.value;
} else if (isReactive(s)) {
return traverse(s);
} else if (_.isFunction(s)) {
return s.call(instance);
} else {
warnInvalidSource(s);
}
});
};
} else if (_.isFunction(source)) {
if (cb) {
// getter with cb
getter = function getter() {
return source.call(instance);
};
} else {
// no cb -> simple effect
getter = function getter() {
if (instance && instance.isUnmounted) {
return;
}
if (cleanup) {
cleanup();
}
return source.call(instance, onInvalidate);
};
}
} else {
getter = function getter() {};
warnInvalidSource(source);
}
if (cb && deep) {
var baseGetter = getter;
getter = function getter() {
return traverse(baseGetter());
};
}
var cleanup;
var onInvalidate = function onInvalidate(fn) {
cleanup = runner.options.onStop = function () {
fn.call(instance);
};
};
var oldValue = _.isArray(source) ? [] : INITIAL_WATCHER_VALUE;
var job = function job() {
if (!runner.active) {
return;
}
if (cb) {
// watch(source, cb)
var newValue = runner();
if (deep || forceTrigger || hasChanged(newValue, oldValue)) {
// cleanup before running cb again
if (cleanup) {
cleanup();
}
cb.apply(instance, [newValue, // pass undefined as the old value when it's changed for the first time
oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, onInvalidate]);
oldValue = newValue;
}
} else {
// watchEffect
runner();
}
}; // important: mark the job as a watcher callback so that scheduler knows
// it is allowed to self-trigger (#1727)
job.allowRecurse = !!cb;
job.id = ++uid;
var scheduler;
if (sync === true) {
scheduler = job;
} else {
scheduler = function scheduler() {
return queueWatcher(job);
};
}
var runner = effect(getter, {
lazy: true,
onTrack: onTrack,
onTrigger: onTrigger,
scheduler: scheduler
}); // initial run
if (cb) {
if (immediate) {
job();
} else {
oldValue = runner();
}
} else {
runner();
}
return function () {
stop(runner);
};
}
function traverse(value) {
var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Set();
if (!_.isObject(value) || seen.has(value)) {
return value;
}
seen.add(value);
if (isRef(value)) {
traverse(value.value, seen);
} else if (_.isArray(value)) {
for (var i = 0; i < value.length; i++) {
traverse(value[i], seen);
}
} else if (isSet(value) || isMap(value)) {
value.forEach(function (v) {
traverse(v, seen);
});
} else {
for (var key in value) {
traverse(value[key], seen);
}
}
return value;
}
var falsy;
var operators = {
"||": falsy,
"&&": falsy,
"(": falsy,
")": falsy
};
function runBinaryFunction(binarys) {
var expr = "";
for (var i = 0, len = binarys.length; i < len; i++) {
if (_.isBoolean(binarys[i]) || _.has(operators, binarys[i])) {
expr += binarys[i];
} else {
expr += "false";
}
}
return new Function("return " + expr)();
}
function watchExp(model, exp) {
var getter = parsePath(exp);
var result = getter.call(model, model);
if (_.isArray(result)) {
return result.concat();
}
return result;
}
function watch(model, expOrFn, cb, options) {
if (isPlainObject(cb)) {
options = cb;
cb = cb.handler;
}
if (typeof cb === "string") {
cb = model[cb];
}
options = options || {};
options.user = true;
var exps;
if (_.isFunction(expOrFn) || !(exps = expOrFn.match(/[a-zA-Z0-9_.*]+|[|][|]|[&][&]|[(]|[)]/g)) || exps.length === 1 && !/\*/.test(expOrFn)) {
var watcher = innerWatch(_.isFunction(expOrFn) ? expOrFn : function () {
return watchExp(model, expOrFn);
}, cb, options);
return function unwatchFn() {
watcher();
};
}
var watchers = [];
var fns = exps.slice();
var complete = false,
running = false;
var callback = function callback(index, newValue, oldValue, attrs) {
if (complete === true) {
return;
}
fns[index] = true;
if (runBinaryFunction(fns)) {
complete = true;
cb(newValue, oldValue, attrs);
}
if (options && options.sync) {
complete = false;
running = false;
fns = exps.slice();
} else {
if (!running) {
running = true;
nextTick(function () {
complete = false;
running = false;
fns = exps.slice();
});
}
}
};
_.each(exps, function (exp, i) {
if (_.has(operators, exp)) {
return;
} //a.**形式
if (/^[1-9a-zA-Z.]+\*\*$/.test(exp) || exp === "**") {
exp = exp.replace(".**", "");
var getter = exp === "**" ? function (m) {
return m;
} : parsePath(exp);
var v = getter.call(model, model);
watchers.push(innerWatch(v, function (newValue, oldValue) {
callback(i, newValue, oldValue, _.extend({
index: i
}));
}));
return;
}
if (/^(\*\*\.)+[1-9a-zA-Z]+(\.\*\*$)/.test(exp)) {
throw new Error("not support");
} //含有*的情况,如a.*,如*.a,*.*.a,a.*.a
if (/\*/.test(exp)) {
// eslint-disable-next-line no-inner-declarations
var travers = function travers(root, deps, parent, key, res) {
if (deps.length === paths.length) {
root !== undefined && res.push({
parent: parent,
k: key
});
return;
}
if (root) {
if (paths[deps.length] === "*") {
// 遍历所有节点
for (var k in root) {
travers(root[k], deps.concat([k]), root, k, res);
}
} else {
var nextKey = paths[deps.length];
travers(root[nextKey], deps.concat([nextKey]), root, nextKey, res);
}
}
};
//先获取到能获取到的对象
var paths = exp.split(".");
var prePaths = [];
for (var _i = 0, len = paths.length; _i < len; _i++) {
if (paths[_i] === "*") {
break;
}
prePaths[_i] = paths[_i];
}
var _v;
if (prePaths.length > 0) {
var _getter = parsePath(prePaths.join("."));
_v = _getter.call(model, model);
} else {
_v = model;
}
paths = paths.slice(prePaths.length);
var changes = [];
watchers.push(innerWatch(function () {
var routes = [];
travers(_v, [], _v, null, routes);
for (var _i2 = 0, _len = routes.length; _i2 < _len; _i2++) {
var _routes$_i = routes[_i2],
parent = _routes$_i.parent,
k = _routes$_i.k;
for (var j = 0, l = changes.length; j < l; j++) {
var _changes$j = changes[j],
target = _changes$j.target,
key = _changes$j.key;
if (target === toRaw(parent) && key === k) {
return true;
}
}
}
}, function (newValue) {
changes = [];
if (newValue === true) {
callback(i, undefined, undefined, _.extend({
index: i
}));
}
}, {
deep: true,
onTrigger: function onTrigger(_ref) {
var target = _ref.target,
key = _ref.key;
changes.push({
target: target,
key: key
});
}
}));
return;
}
watchers.push(innerWatch(function () {
return watchExp(model, exp);
}, function (newValue, oldValue) {
callback(i, newValue, oldValue, _.extend({
index: i
}));
}));
});
return watchers;
}
var REACTIVE = true;
function initState(vm, state) {
if (state) {
vm.$$state = REACTIVE ? reactive(state) : state;
}
}
function initComputed(vm, c) {
var $$computed = vm.$$computed = {};
for (var key in c) {
$$computed[key] = computed(_.bind(c[key], vm));
}
}
function initWatch(vm, watch) {
vm._watchers || (vm._watchers = []);
for (var key in watch) {
var handler = watch[key];
if (_.isArray(handler)) {
for (var i = 0; i < handler.length; i++) {
vm._watchers.push(createWatcher(vm, key, handler[i]));
}
} else {
vm._watchers.push(createWatcher(vm, key, handler));
}
}
}
function createWatcher(vm, keyOrFn, cb, options) {
if (isPlainObject(cb)) {
options = cb;
cb = cb.handler;
}
if (typeof cb === "string") {
cb = vm[cb];
}
return watch(vm.model, keyOrFn, _.bind(cb, vm), options);
}
function initMethods(vm, methods) {
for (var key in methods) {
vm[key] = methods[key] == null ? noop : _.bind(methods[key], vm);
}
}
function initMixins(vm, mixins) {
mixins = mixins || [];
_.each(mixins.reverse(), function (mixinType) {
var mixin = getMixins(mixinType);
for (var key in mixin) {
if (typeof mixin[key] !== "function") continue;
if (_.has(vm, key)) continue;
vm[key] = _.bind(mixin[key], vm);
}
});
}
function defineProps(vm) {
vm.model = new Proxy({}, {
get: function get(target, key) {
if (vm.$$computed && key in vm.$$computed) {
try {
return vm.$$computed[key].value;
} catch (e) {// 吞掉异常
}
return;
}
if (vm.$$state && key in vm.$$state) {
return vm.$$state[key];
}
var p = vm._parent;
while (p) {
if (p.$$context && key in p.$$context) {
return p.$$context[key];
}
p = p._parent;
}
},
set: function set(target, key, value) {
if (vm.$$state && key in vm.$$state) {
vm.$$state[key] = value;
return true;
}
var p = vm._parent;
while (p) {
if (p.$$context && key in p.$$context) {
p.$$context[key] = value;
return true;
}
p = p._parent;
}
return true;
}
});
}
function defineContext(vm, keys) {
var props = {};
var _loop = function _loop(i, len) {
var key = keys[i];
props[key] = {
enumerable: true,
configurable: true,
get: function get() {
return vm.model[key];
},
set: function set(val) {
return vm.model[key] = val;
}
};
};
for (var i = 0, len = keys.length; i < len; i++) {
_loop(i);
}
vm.$$context = Object.defineProperties({}, props);
}
function getInjectValue(vm, key) {
var p = vm._parent;
while (p) {
if (p.$$context && key in p.$$context) {
return p.$$context[key];
}
p = p._parent;
}
}
function getInjectValues(vm) {
var inject = vm.inject || [];
var result = {};
_.each(inject, function (key) {
result[key] = getInjectValue(vm, key);
});
return result;
}
var Model = /*#__PURE__*/function () {
function Model() {
_classCallCheck(this, Model);
}
_createClass(Model, [{
key: "_constructor",
value: function _constructor(options, destroyHandler) {
this.options = options || {};
this._parent = Model.target;
var state = _.isFunction(this.state) ? this.state() : this.state;
var computed = this.computed;
var context = this.context;
var inject = this.inject;
var childContext = this.childContext;
var watch = this.watch;
var actions = this.actions;
_.keys(state).concat(_.keys(computed)).concat(inject || []).concat(context || []);
var mixins = this.mixins;
defineProps(this);
childContext && defineContext(this, childContext);
initMixins(this, mixins);
this.init();
initState(this, _.extend(getInjectValues(this), state));
initComputed(this, computed);
REACTIVE && initWatch(this, watch);
initMethods(this, actions);
this.created && this.created();
this._destroyHandler = destroyHandler;
}
}, {
key: "_init",
value: function _init() {}
}, {
key: "init",
value: function init() {
this._init();
}
}, {
key: "destroy",
value: function destroy() {
_.each(this._watchers, function (unwatches) {
unwatches = _.isArray(unwatches) ? unwatches : [unwatches];
_.each(unwatches, function (unwatch) {
unwatch();
});
});
this._watchers && (this._watchers = []);
this.destroyed && this.destroyed();
this.$$computed = null;
this.$$state = null;
this._destroyHandler && this._destroyHandler();
}
}]);
return Model;
}();
function set(target, key, val) {
if (_.isArray(target)) {
target.length = Math.max(target.length, key);
target.splice(key, 1, val);
return val;
}
target[key] = val;
}
function del(target, key) {
if (_.isArray(target)) {
target.splice(key, 1);
return;
}
if (!_.has(target, key)) {
return;
}
delete target[key];
}
function define(model) {
return REACTIVE ? reactive(model) : model;
}
function config(options) {
options || (options = {});
if ("reactive" in options) {
REACTIVE = options.reactive;
}
}
function toJSON(model) {
var result;
if (_.isArray(model)) {
result = [];
for (var i = 0, len = model.length; i < len; i++) {
result[i] = toJSON(model[i]);
}
} else if (model && isPlainObject(model)) {
result = {};
for (var key in model) {
result[key] = toJSON(model[key]);
}
} else {
result = model;
}
return result;
}
var version = "3.0";
exports.Model = Model;
exports.config = config;
exports.define = define;
exports.del = del;
exports.mixin = mixin;
exports.set = set;
exports.toJSON = toJSON;
exports.version = version;
exports.watch = watch;
Object.defineProperty(exports, '__esModule', { value: true });
})));