From 71ba3aefeec8ab79d214d2998135353b6b68f9c6 Mon Sep 17 00:00:00 2001 From: zsmj1994 Date: Thu, 1 Apr 2021 21:01:43 +0800 Subject: [PATCH] =?UTF-8?q?DEC-17943=20chore=20:=20fineuiProxy=E9=85=8D?= =?UTF-8?q?=E7=BD=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dist/fix/fix.proxy.js | 2035 +++++++++++++++++++++++++++++++++++++ webpack/attachments.js | 16 + webpack/webpack.common.js | 9 + webpack/webpack.prod.js | 4 +- 4 files changed, 2062 insertions(+), 2 deletions(-) create mode 100644 dist/fix/fix.proxy.js diff --git a/dist/fix/fix.proxy.js b/dist/fix/fix.proxy.js new file mode 100644 index 0000000000..210a00555b --- /dev/null +++ b/dist/fix/fix.proxy.js @@ -0,0 +1,2035 @@ +(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 }); + +}))); diff --git a/webpack/attachments.js b/webpack/attachments.js index 2f15597bcb..b141b9bf47 100644 --- a/webpack/attachments.js +++ b/webpack/attachments.js @@ -9,6 +9,7 @@ function sync(patterns) { } const fixJs = "./dist/fix/fix.js"; +const fixProxyJs = './dist/fix/fix.proxy.js'; const fixIEJs = "./dist/fix/fix.ie.js"; const fixCompact = "./dist/fix/fix.compact.js"; const fixIECompact = './dist/fix/fix.compact.ie.js'; @@ -82,6 +83,7 @@ const basicAttachmentMap = { "src/data/**/*.js", ]), fix: [fixJs], + fixProxy: [fixProxyJs], fixIE: [fixIEJs], }; @@ -153,6 +155,18 @@ const fineui = [].concat( basicAttachmentMap.ts, ); +const fineuiProxy = [].concat( + basicAttachmentMap.core, + basicAttachmentMap.fixProxy, + basicAttachmentMap.base, + basicAttachmentMap.case, + basicAttachmentMap.widget, + basicAttachmentMap.router, + [fixCompact, workerCompact], + basicAttachmentMap.ui, + basicAttachmentMap.ts, +); + const fineuiIE = [].concat( basicAttachmentMap.polyfillIE, basicAttachmentMap.core, @@ -202,6 +216,7 @@ const demo = [].concat( module.exports = { fix: fixJs, + fixProxy: fixProxyJs, fixIE: fixIEJs, lodash: lodashJs, font: basicAttachmentMap.font, @@ -209,6 +224,7 @@ module.exports = { bundleIE: uniq(bundleIE), bundleWithoutNormalize: uniq(bundleWithoutNormalize), fineui: uniq(fineui), + fineuiProxy: uniq(fineuiProxy), fineuiIE: uniq(fineuiIE), fineuiWithoutJqueryAndPolyfillJs: uniq(fineuiWithoutJqueryAndPolyfillJs), utils: uniq(basicAttachmentMap.utils), diff --git a/webpack/webpack.common.js b/webpack/webpack.common.js index 14edf56148..a228f61052 100644 --- a/webpack/webpack.common.js +++ b/webpack/webpack.common.js @@ -24,6 +24,7 @@ module.exports = { demo: attachments.demo, // 用于启动dev模式时，工程引用调试 fineui: attachments.fineui, + "fineui.proxy": attachments.fineuiProxy, }, externals: { lodash: '_', @@ -91,6 +92,14 @@ module.exports = { options: 'Fix', }, ], + }, { + test: path.resolve(__dirname, '../', attachments.fixProxy), + use: [ + { + loader: 'expose-loader', + options: 'Fix', + }, + ], }, { test: path.resolve(__dirname, '../', attachments.fixIE), diff --git a/webpack/webpack.prod.js b/webpack/webpack.prod.js index 238618f301..ba61f94881 100644 --- a/webpack/webpack.prod.js +++ b/webpack/webpack.prod.js @@ -16,6 +16,7 @@ module.exports = merge.smart(common, { entry: { font: attachments.font, "fineui.min": attachments.fineui, + "fineui.proxy.min": attachments.fineuiProxy, "fineui.ie.min": attachments.fineuiIE, utils: attachments.utils, "utils.min": attachments.utils, @@ -59,8 +60,7 @@ module.exports = merge.smart(common, { path: dirs.DEST, filename: "[name].css", }), - new ForkTsCheckerWebpackPlugin({ - }), + new ForkTsCheckerWebpackPlugin({}), new OptimizeCssAssetsPlugin({ assetNameRegExp: /\.css$/g, cssProcessor: require("cssnano"),