deno.land / x / solid@v1.5.6 / bench / vuerx.cjs
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805//shared// Make a map and return a function for checking if a key// is in that map.//// IMPORTANT: all calls of this function must be prefixed with /*#__PURE__*/// So that rollup can tree-shake them if necessary.function makeMap(str, expectsLowerCase) { const map = Object.create(null); const list = str.split(','); for (let i = 0; i < list.length; i++) { map[list[i]] = true; } return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];}
const EMPTY_OBJ = Object.freeze({});
const hasOwnProperty = Object.prototype.hasOwnProperty;const hasOwn = (val, key) => hasOwnProperty.call(val, key);const isArray = Array.isArray;const isFunction = (val) => typeof val === 'function';const isSymbol = (val) => typeof val === 'symbol';const isObject = (val) => val !== null && typeof val === 'object';const objectToString = Object.prototype.toString;const toTypeString = (value) => objectToString.call(value);const toRawType = (value) => { return toTypeString(value).slice(8, -1);};const cacheStringFunction = (fn) => { const cache = Object.create(null); return ((str) => { const hit = cache[str]; return hit || (cache[str] = fn(str)); });};const capitalize = cacheStringFunction((str) => { return str.charAt(0).toUpperCase() + str.slice(1);});// compare whether a value has changed, accounting for NaN.const hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);const def = (obj, key, value) => { Object.defineProperty(obj, key, { configurable: true, value });};
//vue-rxconst targetMap = new WeakMap();const effectStack = [];let activeEffect;const ITERATE_KEY = Symbol( 'iterate' );const MAP_KEY_ITERATE_KEY = Symbol( 'Map key iterate' );function isEffect(fn) { return fn && fn._isEffect === true;}function effect(fn, options = EMPTY_OBJ) { if (isEffect(fn)) { fn = fn.raw; } const 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; }}let uid = 0;function createReactiveEffect(fn, options) { const effect = function reactiveEffect(...args) { if (!effect.active) { return options.scheduler ? undefined : fn(...args); } if (!effectStack.includes(effect)) { cleanup(effect); try { enableTracking(); effectStack.push(effect); activeEffect = effect; return fn(...args); } finally { effectStack.pop(); resetTracking(); activeEffect = effectStack[effectStack.length - 1]; } } }; effect.id = uid++; effect._isEffect = true; effect.active = true; effect.raw = fn; effect.deps = []; effect.options = options; return effect;}function cleanup(effect) { const { deps } = effect; if (deps.length) { for (let i = 0; i < deps.length; i++) { deps[i].delete(effect); } deps.length = 0; }}let shouldTrack = true;const trackStack = [];function pauseTracking() { trackStack.push(shouldTrack); shouldTrack = false;}function enableTracking() { trackStack.push(shouldTrack); shouldTrack = true;}function resetTracking() { const last = trackStack.pop(); shouldTrack = last === undefined ? true : last;}function track(target, type, key) { if (!shouldTrack || activeEffect === undefined) { return; } let depsMap = targetMap.get(target); if (!depsMap) { targetMap.set(target, (depsMap = new Map())); } let 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, type, key }); } }}function trigger(target, type, key, newValue, oldValue, oldTarget) { const depsMap = targetMap.get(target); if (!depsMap) { // never been tracked return; } const effects = new Set(); const computedRunners = new Set(); const add = (effectsToAdd) => { if (effectsToAdd) { effectsToAdd.forEach(effect => { if (effect !== activeEffect || !shouldTrack) { if (effect.options.computed) { computedRunners.add(effect); } else { 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((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 const isAddOrDelete = type === "add" /* ADD */ || (type === "delete" /* DELETE */ && !isArray(target)); if (isAddOrDelete || (type === "set" /* SET */ && target instanceof Map)) { add(depsMap.get(isArray(target) ? 'length' : ITERATE_KEY)); } if (isAddOrDelete && target instanceof Map) { add(depsMap.get(MAP_KEY_ITERATE_KEY)); } } const run = (effect) => { if ( effect.options.onTrigger) { effect.options.onTrigger({ effect, target, key, type, newValue, oldValue, oldTarget }); } if (effect.options.scheduler) { effect.options.scheduler(effect); } else { effect(); } }; // Important: computed effects must be run first so that computed getters // can be invalidated before any normal effects that depend on them are run. computedRunners.forEach(run); effects.forEach(run);}
const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol) .map(key => Symbol[key]) .filter(isSymbol));const get = /*#__PURE__*/ createGetter();const shallowGet = /*#__PURE__*/ createGetter(false, true);const readonlyGet = /*#__PURE__*/ createGetter(true);const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);const arrayInstrumentations = {};['includes', 'indexOf', 'lastIndexOf'].forEach(key => { arrayInstrumentations[key] = function (...args) { const arr = toRaw(this); for (let i = 0, l = this.length; i < l; i++) { track(arr, "get" /* GET */, i + ''); } // we run the method using the original args first (which may be reactive) const res = arr[key](...args); if (res === -1 || res === false) { // if that didn't work, run it again using raw values. return arr[key](...args.map(toRaw)); } else { return res; } };});function createGetter(isReadonly = false, shallow = false) { return function get(target, key, receiver) { if (key === "__v_isReactive" /* isReactive */) { return !isReadonly; } else if (key === "__v_isReadonly" /* isReadonly */) { return isReadonly; } else if (key === "__v_raw" /* raw */) { return target; } const targetIsArray = isArray(target); if (targetIsArray && hasOwn(arrayInstrumentations, key)) { return Reflect.get(arrayInstrumentations, key, receiver); } const res = Reflect.get(target, key, receiver); if (isSymbol(key) && builtInSymbols.has(key) || key === '__proto__') { return res; } if (shallow) { !isReadonly && track(target, "get" /* GET */, key); return res; } if (isRef(res)) { if (targetIsArray) { !isReadonly && track(target, "get" /* GET */, key); return res; } else { // ref unwrapping, only for Objects, not for Arrays. return res.value; } } !isReadonly && track(target, "get" /* GET */, key); return isObject(res) ? isReadonly ? // need to lazy access readonly and reactive here to avoid // circular dependency readonly(res) : reactive(res) : res; };}const set = /*#__PURE__*/ createSetter();const shallowSet = /*#__PURE__*/ createSetter(true);function createSetter(shallow = false) { return function set(target, key, value, receiver) { const oldValue = target[key]; if (!shallow) { value = toRaw(value); if (!isArray(target) && isRef(oldValue) && !isRef(value)) { oldValue.value = value; return true; } } const hadKey = hasOwn(target, key); const 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(value, oldValue)) { trigger(target, "set" /* SET */, key, value, oldValue); } } return result; };}function deleteProperty(target, key) { const hadKey = hasOwn(target, key); const oldValue = target[key]; const result = Reflect.deleteProperty(target, key); if (result && hadKey) { trigger(target, "delete" /* DELETE */, key, undefined, oldValue); } return result;}function has(target, key) { const result = Reflect.has(target, key); track(target, "has" /* HAS */, key); return result;}function ownKeys(target) { track(target, "iterate" /* ITERATE */, ITERATE_KEY); return Reflect.ownKeys(target);}const mutableHandlers = { get, set, deleteProperty, has, ownKeys};const readonlyHandlers = { get: readonlyGet, has, ownKeys, set(target, key) { { console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target); } return true; }, deleteProperty(target, key) { { console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); } return true; }};const shallowReactiveHandlers = { ...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.const shallowReadonlyHandlers = { ...readonlyHandlers, get: shallowReadonlyGet};
const toReactive = (value) => isObject(value) ? reactive(value) : value;const toReadonly = (value) => isObject(value) ? readonly(value) : value;const getProto = (v) => Reflect.getPrototypeOf(v);function get$1(target, key, wrap) { target = toRaw(target); const rawKey = toRaw(key); if (key !== rawKey) { track(target, "get" /* GET */, key); } track(target, "get" /* GET */, rawKey); const { has, get } = getProto(target); if (has.call(target, key)) { return wrap(get.call(target, key)); } else if (has.call(target, rawKey)) { return wrap(get.call(target, rawKey)); }}function has$1(key) { const target = toRaw(this); const rawKey = toRaw(key); if (key !== rawKey) { track(target, "has" /* HAS */, key); } track(target, "has" /* HAS */, rawKey); const has = getProto(target).has; return has.call(target, key) || has.call(target, rawKey);}function size(target) { target = toRaw(target); track(target, "iterate" /* ITERATE */, ITERATE_KEY); return Reflect.get(getProto(target), 'size', target);}function add(value) { value = toRaw(value); const target = toRaw(this); const proto = getProto(target); const hadKey = proto.has.call(target, value); const result = proto.add.call(target, value); if (!hadKey) { trigger(target, "add" /* ADD */, value, value); } return result;}function set$1(key, value) { value = toRaw(value); const target = toRaw(this); const { has, get, set } = getProto(target); let hadKey = has.call(target, key); if (!hadKey) { key = toRaw(key); hadKey = has.call(target, key); } else { checkIdentityKeys(target, has, key); } const oldValue = get.call(target, key); const result = set.call(target, key, value); if (!hadKey) { trigger(target, "add" /* ADD */, key, value); } else if (hasChanged(value, oldValue)) { trigger(target, "set" /* SET */, key, value, oldValue); } return result;}function deleteEntry(key) { const target = toRaw(this); const { has, get, delete: del } = getProto(target); let hadKey = has.call(target, key); if (!hadKey) { key = toRaw(key); hadKey = has.call(target, key); } else { checkIdentityKeys(target, has, key); } const oldValue = get ? get.call(target, key) : undefined; // forward the operation before queueing reactions const result = del.call(target, key); if (hadKey) { trigger(target, "delete" /* DELETE */, key, undefined, oldValue); } return result;}function clear() { const target = toRaw(this); const hadItems = target.size !== 0; const oldTarget = target instanceof Map ? new Map(target) : new Set(target) ; // forward the operation before queueing reactions const result = getProto(target).clear.call(target); if (hadItems) { trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget); } return result;}function createForEach(isReadonly) { return function forEach(callback, thisArg) { const observed = this; const target = toRaw(observed); const wrap = isReadonly ? toReadonly : toReactive; !isReadonly && track(target, "iterate" /* ITERATE */, ITERATE_KEY); // important: create 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. function wrappedCallback(value, key) { return callback.call(thisArg, wrap(value), wrap(key), observed); } return getProto(target).forEach.call(target, wrappedCallback); };}function createIterableMethod(method, isReadonly) { return function (...args) { const target = toRaw(this); const isMap = target instanceof Map; const isPair = method === 'entries' || (method === Symbol.iterator && isMap); const isKeyOnly = method === 'keys' && isMap; const innerIterator = getProto(target)[method].apply(target, args); const wrap = isReadonly ? toReadonly : toReactive; !isReadonly && track(target, "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 { // iterator protocol next() { const { value, done } = innerIterator.next(); return done ? { value, done } : { value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), done }; }, // iterable protocol [Symbol.iterator]() { return this; } }; };}function createReadonlyMethod(type) { return function (...args) { { const key = args[0] ? `on key "${args[0]}" ` : ``; console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this)); } return type === "delete" /* DELETE */ ? false : this; };}const mutableInstrumentations = { get(key) { return get$1(this, key, toReactive); }, get size() { return size(this); }, has: has$1, add, set: set$1, delete: deleteEntry, clear, forEach: createForEach(false)};const readonlyInstrumentations = { get(key) { return get$1(this, key, toReadonly); }, get size() { return size(this); }, has: has$1, add: createReadonlyMethod("add" /* ADD */), set: createReadonlyMethod("set" /* SET */), delete: createReadonlyMethod("delete" /* DELETE */), clear: createReadonlyMethod("clear" /* CLEAR */), forEach: createForEach(true)};const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];iteratorMethods.forEach(method => { mutableInstrumentations[method] = createIterableMethod(method, false); readonlyInstrumentations[method] = createIterableMethod(method, true);});function createInstrumentationGetter(isReadonly) { const instrumentations = isReadonly ? readonlyInstrumentations : mutableInstrumentations; return (target, key, receiver) => { if (key === "__v_isReactive" /* isReactive */) { return !isReadonly; } else if (key === "__v_isReadonly" /* isReadonly */) { return isReadonly; } else if (key === "__v_raw" /* raw */) { return target; } return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver); };}const mutableCollectionHandlers = { get: createInstrumentationGetter(false)};const readonlyCollectionHandlers = { get: createInstrumentationGetter(true)};function checkIdentityKeys(target, has, key) { const rawKey = toRaw(key); if (rawKey !== key && has.call(target, rawKey)) { const type = toRawType(target); console.warn(`Reactive ${type} contains both the raw and reactive ` + `versions of the same object${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.`); }}
const collectionTypes = new Set([Set, Map, WeakMap, WeakSet]);const isObservableType = /*#__PURE__*/ makeMap('Object,Array,Map,Set,WeakMap,WeakSet');const canObserve = (value) => { return (!value.__v_skip && isObservableType(toRawType(value)) && !Object.isFrozen(value));};function reactive(target) { // if trying to observe a readonly proxy, return the readonly version. if (target && target.__v_isReadonly) { return target; } return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);}// Return a reactive-copy of the original object, where only the root level// properties are reactive, and does NOT unwrap refs nor recursively convert// returned properties.function shallowReactive(target) { return createReactiveObject(target, false, shallowReactiveHandlers, mutableCollectionHandlers);}function readonly(target) { return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);}// Return a reactive-copy of the original object, where only the root level// properties are readonly, and does NOT unwrap refs nor recursively convert// returned properties.// This is used for creating the props proxy object for stateful components.function shallowReadonly(target) { return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);}function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) { if (!isObject(target)) { { console.warn(`value cannot be made reactive: ${String(target)}`); } return target; } // target is already a Proxy, return it. // exception: calling readonly() on a reactive object if (target.__v_raw && !(isReadonly && target.__v_isReactive)) { return target; } // target already has corresponding Proxy if (hasOwn(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */)) { return isReadonly ? target.__v_readonly : target.__v_reactive; } // only a whitelist of value types can be observed. if (!canObserve(target)) { return target; } const observed = new Proxy(target, collectionTypes.has(target.constructor) ? collectionHandlers : baseHandlers); def(target, isReadonly ? "__v_readonly" /* readonly */ : "__v_reactive" /* reactive */, observed); return observed;}function isReactive(value) { if (isReadonly(value)) { return isReactive(value.__v_raw); } return !!(value && value.__v_isReactive);}function isReadonly(value) { return !!(value && value.__v_isReadonly);}function isProxy(value) { return isReactive(value) || isReadonly(value);}function toRaw(observed) { return (observed && toRaw(observed.__v_raw)) || observed;}function markRaw(value) { def(value, "__v_skip" /* skip */, true); return value;}
const convert = (val) => isObject(val) ? reactive(val) : val;function isRef(r) { return r ? r.__v_isRef === true : false;}function ref(value) { return createRef(value);}function shallowRef(value) { return createRef(value, true);}function createRef(rawValue, shallow = false) { if (isRef(rawValue)) { return rawValue; } let value = shallow ? rawValue : convert(rawValue); const r = { __v_isRef: true, get value() { track(r, "get" /* GET */, 'value'); return value; }, set value(newVal) { if (hasChanged(toRaw(newVal), rawValue)) { rawValue = newVal; value = shallow ? newVal : convert(newVal); trigger(r, "set" /* SET */, 'value', { newValue: newVal } ); } } }; return r;}function triggerRef(ref) { trigger(ref, "set" /* SET */, 'value', { newValue: ref.value } );}function unref(ref) { return isRef(ref) ? ref.value : ref;}function customRef(factory) { const { get, set } = factory(() => track(r, "get" /* GET */, 'value'), () => trigger(r, "set" /* SET */, 'value')); const r = { __v_isRef: true, get value() { return get(); }, set value(v) { set(v); } }; return r;}function toRefs(object) { if ( !isProxy(object)) { console.warn(`toRefs() expects a reactive object but received a plain one.`); } const ret = {}; for (const key in object) { ret[key] = toRef(object, key); } return ret;}function toRef(object, key) { return { __v_isRef: true, get value() { return object[key]; }, set value(newVal) { object[key] = newVal; } };}
function computed(getterOrOptions) { let getter; let setter; if (isFunction(getterOrOptions)) { getter = getterOrOptions; setter = () => { console.warn('Write operation failed: computed value is readonly'); } ; } else { getter = getterOrOptions.get; setter = getterOrOptions.set; } let dirty = true; let value; let computed; const runner = effect(getter, { lazy: true, // mark effect as computed so that it gets priority during trigger computed: true, scheduler: () => { if (!dirty) { dirty = true; trigger(computed, "set" /* SET */, 'value'); } } }); computed = { __v_isRef: true, // expose effect so computed can be stopped effect: runner, get value() { if (dirty) { value = runner(); dirty = false; } track(computed, "get" /* GET */, 'value'); return value; }, set value(newValue) { setter(newValue); } }; return computed;}
function createSignal(value) { const r = shallowRef(value); return [() => r.value, v => r.value = v];}
function createRoot(fn) { return fn(); }
module.exports = { createSignal, createRoot, createComputed: effect};
solid
Version Info
a year ago
