wevu 0.0.1 → 1.0.0-alpha.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +119 -0
- package/dist/index-0dF4y5p6.d.mts +80 -0
- package/dist/index-DVEFI-Uo.d.cts +80 -0
- package/dist/index.cjs +525 -154
- package/dist/index.d.cts +397 -54
- package/dist/index.d.mts +397 -54
- package/dist/index.mjs +465 -119
- package/dist/store-BcU7YVhB.mjs +638 -0
- package/dist/store-Cmw9vWBT.cjs +764 -0
- package/dist/store.cjs +4 -246
- package/dist/store.d.cts +2 -69
- package/dist/store.d.mts +2 -69
- package/dist/store.mjs +1 -243
- package/package.json +24 -16
- package/dist/ref-0isFdYQ8.d.cts +0 -9
- package/dist/ref-BHYwO374.d.mts +0 -9
- package/dist/ref-DS-k2oUF.mjs +0 -271
- package/dist/ref-DtCdcykK.cjs +0 -349
package/dist/ref-0isFdYQ8.d.cts
DELETED
|
@@ -1,9 +0,0 @@
|
|
|
1
|
-
//#region src/reactivity/ref.d.ts
|
|
2
|
-
interface Ref<T = any> {
|
|
3
|
-
value: T;
|
|
4
|
-
}
|
|
5
|
-
declare function isRef(value: unknown): value is Ref<any>;
|
|
6
|
-
declare function ref<T>(value: T): Ref<T>;
|
|
7
|
-
declare function unref<T>(value: T | Ref<T>): T;
|
|
8
|
-
//#endregion
|
|
9
|
-
export { unref as i, isRef as n, ref as r, Ref as t };
|
package/dist/ref-BHYwO374.d.mts
DELETED
|
@@ -1,9 +0,0 @@
|
|
|
1
|
-
//#region src/reactivity/ref.d.ts
|
|
2
|
-
interface Ref<T = any> {
|
|
3
|
-
value: T;
|
|
4
|
-
}
|
|
5
|
-
declare function isRef(value: unknown): value is Ref<any>;
|
|
6
|
-
declare function ref<T>(value: T): Ref<T>;
|
|
7
|
-
declare function unref<T>(value: T | Ref<T>): T;
|
|
8
|
-
//#endregion
|
|
9
|
-
export { unref as i, isRef as n, ref as r, Ref as t };
|
package/dist/ref-DS-k2oUF.mjs
DELETED
|
@@ -1,271 +0,0 @@
|
|
|
1
|
-
//#region src/scheduler.ts
|
|
2
|
-
const resolvedPromise = Promise.resolve();
|
|
3
|
-
const jobQueue = /* @__PURE__ */ new Set();
|
|
4
|
-
let isFlushing = false;
|
|
5
|
-
function flushJobs() {
|
|
6
|
-
isFlushing = true;
|
|
7
|
-
try {
|
|
8
|
-
jobQueue.forEach((job) => job());
|
|
9
|
-
} finally {
|
|
10
|
-
jobQueue.clear();
|
|
11
|
-
isFlushing = false;
|
|
12
|
-
}
|
|
13
|
-
}
|
|
14
|
-
function queueJob(job) {
|
|
15
|
-
jobQueue.add(job);
|
|
16
|
-
if (!isFlushing) resolvedPromise.then(flushJobs);
|
|
17
|
-
}
|
|
18
|
-
function nextTick(fn) {
|
|
19
|
-
return fn ? resolvedPromise.then(fn) : resolvedPromise;
|
|
20
|
-
}
|
|
21
|
-
|
|
22
|
-
//#endregion
|
|
23
|
-
//#region src/reactivity/core.ts
|
|
24
|
-
const targetMap = /* @__PURE__ */ new WeakMap();
|
|
25
|
-
let activeEffect = null;
|
|
26
|
-
const effectStack = [];
|
|
27
|
-
function cleanupEffect(effect$1) {
|
|
28
|
-
const { deps } = effect$1;
|
|
29
|
-
for (let i = 0; i < deps.length; i++) deps[i].delete(effect$1);
|
|
30
|
-
deps.length = 0;
|
|
31
|
-
}
|
|
32
|
-
function createReactiveEffect(fn, options = {}) {
|
|
33
|
-
const effect$1 = function reactiveEffect() {
|
|
34
|
-
if (!effect$1.active) return fn();
|
|
35
|
-
if (effectStack.includes(effect$1)) return fn();
|
|
36
|
-
cleanupEffect(effect$1);
|
|
37
|
-
try {
|
|
38
|
-
effectStack.push(effect$1);
|
|
39
|
-
activeEffect = effect$1;
|
|
40
|
-
return fn();
|
|
41
|
-
} finally {
|
|
42
|
-
effectStack.pop();
|
|
43
|
-
activeEffect = effectStack[effectStack.length - 1] ?? null;
|
|
44
|
-
}
|
|
45
|
-
};
|
|
46
|
-
effect$1.deps = [];
|
|
47
|
-
effect$1.scheduler = options.scheduler;
|
|
48
|
-
effect$1.onStop = options.onStop;
|
|
49
|
-
effect$1.active = true;
|
|
50
|
-
effect$1._fn = fn;
|
|
51
|
-
return effect$1;
|
|
52
|
-
}
|
|
53
|
-
function effect(fn, options = {}) {
|
|
54
|
-
const _effect = createReactiveEffect(fn, options);
|
|
55
|
-
if (!options.lazy) _effect();
|
|
56
|
-
return _effect;
|
|
57
|
-
}
|
|
58
|
-
function stop(runner) {
|
|
59
|
-
if (!runner.active) return;
|
|
60
|
-
runner.active = false;
|
|
61
|
-
cleanupEffect(runner);
|
|
62
|
-
runner.onStop?.();
|
|
63
|
-
}
|
|
64
|
-
function track(target, key) {
|
|
65
|
-
if (!activeEffect) return;
|
|
66
|
-
let depsMap = targetMap.get(target);
|
|
67
|
-
if (!depsMap) {
|
|
68
|
-
depsMap = /* @__PURE__ */ new Map();
|
|
69
|
-
targetMap.set(target, depsMap);
|
|
70
|
-
}
|
|
71
|
-
let dep = depsMap.get(key);
|
|
72
|
-
if (!dep) {
|
|
73
|
-
dep = /* @__PURE__ */ new Set();
|
|
74
|
-
depsMap.set(key, dep);
|
|
75
|
-
}
|
|
76
|
-
if (!dep.has(activeEffect)) {
|
|
77
|
-
dep.add(activeEffect);
|
|
78
|
-
activeEffect.deps.push(dep);
|
|
79
|
-
}
|
|
80
|
-
}
|
|
81
|
-
function trigger(target, key) {
|
|
82
|
-
const depsMap = targetMap.get(target);
|
|
83
|
-
if (!depsMap) return;
|
|
84
|
-
const effects = depsMap.get(key);
|
|
85
|
-
if (!effects) return;
|
|
86
|
-
const effectsToRun = /* @__PURE__ */ new Set();
|
|
87
|
-
effects.forEach((ef) => {
|
|
88
|
-
if (ef !== activeEffect) effectsToRun.add(ef);
|
|
89
|
-
});
|
|
90
|
-
effectsToRun.forEach((ef) => {
|
|
91
|
-
if (ef.scheduler) ef.scheduler();
|
|
92
|
-
else ef();
|
|
93
|
-
});
|
|
94
|
-
}
|
|
95
|
-
function trackEffects(dep) {
|
|
96
|
-
if (!activeEffect) return;
|
|
97
|
-
if (!dep.has(activeEffect)) {
|
|
98
|
-
dep.add(activeEffect);
|
|
99
|
-
activeEffect.deps.push(dep);
|
|
100
|
-
}
|
|
101
|
-
}
|
|
102
|
-
function triggerEffects(dep) {
|
|
103
|
-
dep.forEach((ef) => {
|
|
104
|
-
if (ef.scheduler) ef.scheduler();
|
|
105
|
-
else ef();
|
|
106
|
-
});
|
|
107
|
-
}
|
|
108
|
-
|
|
109
|
-
//#endregion
|
|
110
|
-
//#region src/reactivity/computed.ts
|
|
111
|
-
function computed(getterOrOptions) {
|
|
112
|
-
let getter;
|
|
113
|
-
let setter;
|
|
114
|
-
const onlyGetter = typeof getterOrOptions === "function";
|
|
115
|
-
if (onlyGetter) {
|
|
116
|
-
getter = getterOrOptions;
|
|
117
|
-
setter = () => {
|
|
118
|
-
throw new Error("Computed value is readonly");
|
|
119
|
-
};
|
|
120
|
-
} else {
|
|
121
|
-
getter = getterOrOptions.get;
|
|
122
|
-
setter = getterOrOptions.set;
|
|
123
|
-
}
|
|
124
|
-
let value;
|
|
125
|
-
let dirty = true;
|
|
126
|
-
let runner;
|
|
127
|
-
const obj = {
|
|
128
|
-
get value() {
|
|
129
|
-
if (dirty) {
|
|
130
|
-
value = runner();
|
|
131
|
-
dirty = false;
|
|
132
|
-
}
|
|
133
|
-
track(obj, "value");
|
|
134
|
-
return value;
|
|
135
|
-
},
|
|
136
|
-
set value(newValue) {
|
|
137
|
-
setter(newValue);
|
|
138
|
-
}
|
|
139
|
-
};
|
|
140
|
-
runner = effect(getter, {
|
|
141
|
-
lazy: true,
|
|
142
|
-
scheduler: () => {
|
|
143
|
-
if (!dirty) {
|
|
144
|
-
dirty = true;
|
|
145
|
-
trigger(obj, "value");
|
|
146
|
-
}
|
|
147
|
-
}
|
|
148
|
-
});
|
|
149
|
-
return onlyGetter ? obj : obj;
|
|
150
|
-
}
|
|
151
|
-
|
|
152
|
-
//#endregion
|
|
153
|
-
//#region src/reactivity/reactive.ts
|
|
154
|
-
const reactiveMap = /* @__PURE__ */ new WeakMap();
|
|
155
|
-
const rawMap = /* @__PURE__ */ new WeakMap();
|
|
156
|
-
const rawRootMap = /* @__PURE__ */ new WeakMap();
|
|
157
|
-
let ReactiveFlags = /* @__PURE__ */ function(ReactiveFlags$1) {
|
|
158
|
-
ReactiveFlags$1["IS_REACTIVE"] = "__r_isReactive";
|
|
159
|
-
ReactiveFlags$1["RAW"] = "__r_raw";
|
|
160
|
-
return ReactiveFlags$1;
|
|
161
|
-
}({});
|
|
162
|
-
function isObject(value) {
|
|
163
|
-
return typeof value === "object" && value !== null;
|
|
164
|
-
}
|
|
165
|
-
const VERSION_KEY = Symbol("wevu.version");
|
|
166
|
-
const mutableHandlers = {
|
|
167
|
-
get(target, key, receiver) {
|
|
168
|
-
if (key === ReactiveFlags.IS_REACTIVE) return true;
|
|
169
|
-
if (key === ReactiveFlags.RAW) return target;
|
|
170
|
-
const res = Reflect.get(target, key, receiver);
|
|
171
|
-
track(target, key);
|
|
172
|
-
if (isObject(res)) {
|
|
173
|
-
const child = res;
|
|
174
|
-
const parentRoot = rawRootMap.get(target) ?? target;
|
|
175
|
-
if (!rawRootMap.has(child)) rawRootMap.set(child, parentRoot);
|
|
176
|
-
return reactive(res);
|
|
177
|
-
}
|
|
178
|
-
return res;
|
|
179
|
-
},
|
|
180
|
-
set(target, key, value, receiver) {
|
|
181
|
-
const oldValue = Reflect.get(target, key, receiver);
|
|
182
|
-
const result = Reflect.set(target, key, value, receiver);
|
|
183
|
-
if (!Object.is(oldValue, value)) {
|
|
184
|
-
trigger(target, key);
|
|
185
|
-
trigger(target, VERSION_KEY);
|
|
186
|
-
const root = rawRootMap.get(target);
|
|
187
|
-
if (root && root !== target) trigger(root, VERSION_KEY);
|
|
188
|
-
}
|
|
189
|
-
return result;
|
|
190
|
-
},
|
|
191
|
-
deleteProperty(target, key) {
|
|
192
|
-
const hadKey = Object.prototype.hasOwnProperty.call(target, key);
|
|
193
|
-
const result = Reflect.deleteProperty(target, key);
|
|
194
|
-
if (hadKey && result) {
|
|
195
|
-
trigger(target, key);
|
|
196
|
-
trigger(target, VERSION_KEY);
|
|
197
|
-
const root = rawRootMap.get(target);
|
|
198
|
-
if (root && root !== target) trigger(root, VERSION_KEY);
|
|
199
|
-
}
|
|
200
|
-
return result;
|
|
201
|
-
},
|
|
202
|
-
ownKeys(target) {
|
|
203
|
-
track(target, Symbol.iterator);
|
|
204
|
-
track(target, VERSION_KEY);
|
|
205
|
-
return Reflect.ownKeys(target);
|
|
206
|
-
}
|
|
207
|
-
};
|
|
208
|
-
function reactive(target) {
|
|
209
|
-
if (!isObject(target)) return target;
|
|
210
|
-
const existingProxy = reactiveMap.get(target);
|
|
211
|
-
if (existingProxy) return existingProxy;
|
|
212
|
-
if (target[ReactiveFlags.IS_REACTIVE]) return target;
|
|
213
|
-
const proxy = new Proxy(target, mutableHandlers);
|
|
214
|
-
reactiveMap.set(target, proxy);
|
|
215
|
-
rawMap.set(proxy, target);
|
|
216
|
-
if (!rawRootMap.has(target)) rawRootMap.set(target, target);
|
|
217
|
-
return proxy;
|
|
218
|
-
}
|
|
219
|
-
function isReactive(value) {
|
|
220
|
-
return Boolean(value && value[ReactiveFlags.IS_REACTIVE]);
|
|
221
|
-
}
|
|
222
|
-
function toRaw(observed) {
|
|
223
|
-
return observed?.[ReactiveFlags.RAW] ?? observed;
|
|
224
|
-
}
|
|
225
|
-
function convertToReactive(value) {
|
|
226
|
-
return isObject(value) ? reactive(value) : value;
|
|
227
|
-
}
|
|
228
|
-
/**
|
|
229
|
-
* Establish a dependency on the whole reactive object "version".
|
|
230
|
-
* This lets effects react to any change on the object without deep traverse.
|
|
231
|
-
*/
|
|
232
|
-
function touchReactive(target) {
|
|
233
|
-
track(toRaw(target), VERSION_KEY);
|
|
234
|
-
}
|
|
235
|
-
|
|
236
|
-
//#endregion
|
|
237
|
-
//#region src/reactivity/ref.ts
|
|
238
|
-
function isRef(value) {
|
|
239
|
-
return Boolean(value && typeof value === "object" && "value" in value);
|
|
240
|
-
}
|
|
241
|
-
var RefImpl = class {
|
|
242
|
-
_value;
|
|
243
|
-
_rawValue;
|
|
244
|
-
dep;
|
|
245
|
-
constructor(value) {
|
|
246
|
-
this._rawValue = value;
|
|
247
|
-
this._value = convertToReactive(value);
|
|
248
|
-
}
|
|
249
|
-
get value() {
|
|
250
|
-
if (!this.dep) this.dep = /* @__PURE__ */ new Set();
|
|
251
|
-
trackEffects(this.dep);
|
|
252
|
-
return this._value;
|
|
253
|
-
}
|
|
254
|
-
set value(newValue) {
|
|
255
|
-
if (!Object.is(newValue, this._rawValue)) {
|
|
256
|
-
this._rawValue = newValue;
|
|
257
|
-
this._value = convertToReactive(newValue);
|
|
258
|
-
if (this.dep) triggerEffects(this.dep);
|
|
259
|
-
}
|
|
260
|
-
}
|
|
261
|
-
};
|
|
262
|
-
function ref(value) {
|
|
263
|
-
if (isRef(value)) return value;
|
|
264
|
-
return new RefImpl(value);
|
|
265
|
-
}
|
|
266
|
-
function unref(value) {
|
|
267
|
-
return isRef(value) ? value.value : value;
|
|
268
|
-
}
|
|
269
|
-
|
|
270
|
-
//#endregion
|
|
271
|
-
export { isReactive as a, touchReactive as c, stop as d, nextTick as f, isObject as i, computed as l, ref as n, reactive as o, queueJob as p, unref as r, toRaw as s, isRef as t, effect as u };
|
package/dist/ref-DtCdcykK.cjs
DELETED
|
@@ -1,349 +0,0 @@
|
|
|
1
|
-
|
|
2
|
-
//#region src/scheduler.ts
|
|
3
|
-
const resolvedPromise = Promise.resolve();
|
|
4
|
-
const jobQueue = /* @__PURE__ */ new Set();
|
|
5
|
-
let isFlushing = false;
|
|
6
|
-
function flushJobs() {
|
|
7
|
-
isFlushing = true;
|
|
8
|
-
try {
|
|
9
|
-
jobQueue.forEach((job) => job());
|
|
10
|
-
} finally {
|
|
11
|
-
jobQueue.clear();
|
|
12
|
-
isFlushing = false;
|
|
13
|
-
}
|
|
14
|
-
}
|
|
15
|
-
function queueJob(job) {
|
|
16
|
-
jobQueue.add(job);
|
|
17
|
-
if (!isFlushing) resolvedPromise.then(flushJobs);
|
|
18
|
-
}
|
|
19
|
-
function nextTick(fn) {
|
|
20
|
-
return fn ? resolvedPromise.then(fn) : resolvedPromise;
|
|
21
|
-
}
|
|
22
|
-
|
|
23
|
-
//#endregion
|
|
24
|
-
//#region src/reactivity/core.ts
|
|
25
|
-
const targetMap = /* @__PURE__ */ new WeakMap();
|
|
26
|
-
let activeEffect = null;
|
|
27
|
-
const effectStack = [];
|
|
28
|
-
function cleanupEffect(effect$1) {
|
|
29
|
-
const { deps } = effect$1;
|
|
30
|
-
for (let i = 0; i < deps.length; i++) deps[i].delete(effect$1);
|
|
31
|
-
deps.length = 0;
|
|
32
|
-
}
|
|
33
|
-
function createReactiveEffect(fn, options = {}) {
|
|
34
|
-
const effect$1 = function reactiveEffect() {
|
|
35
|
-
if (!effect$1.active) return fn();
|
|
36
|
-
if (effectStack.includes(effect$1)) return fn();
|
|
37
|
-
cleanupEffect(effect$1);
|
|
38
|
-
try {
|
|
39
|
-
effectStack.push(effect$1);
|
|
40
|
-
activeEffect = effect$1;
|
|
41
|
-
return fn();
|
|
42
|
-
} finally {
|
|
43
|
-
effectStack.pop();
|
|
44
|
-
activeEffect = effectStack[effectStack.length - 1] ?? null;
|
|
45
|
-
}
|
|
46
|
-
};
|
|
47
|
-
effect$1.deps = [];
|
|
48
|
-
effect$1.scheduler = options.scheduler;
|
|
49
|
-
effect$1.onStop = options.onStop;
|
|
50
|
-
effect$1.active = true;
|
|
51
|
-
effect$1._fn = fn;
|
|
52
|
-
return effect$1;
|
|
53
|
-
}
|
|
54
|
-
function effect(fn, options = {}) {
|
|
55
|
-
const _effect = createReactiveEffect(fn, options);
|
|
56
|
-
if (!options.lazy) _effect();
|
|
57
|
-
return _effect;
|
|
58
|
-
}
|
|
59
|
-
function stop(runner) {
|
|
60
|
-
if (!runner.active) return;
|
|
61
|
-
runner.active = false;
|
|
62
|
-
cleanupEffect(runner);
|
|
63
|
-
runner.onStop?.();
|
|
64
|
-
}
|
|
65
|
-
function track(target, key) {
|
|
66
|
-
if (!activeEffect) return;
|
|
67
|
-
let depsMap = targetMap.get(target);
|
|
68
|
-
if (!depsMap) {
|
|
69
|
-
depsMap = /* @__PURE__ */ new Map();
|
|
70
|
-
targetMap.set(target, depsMap);
|
|
71
|
-
}
|
|
72
|
-
let dep = depsMap.get(key);
|
|
73
|
-
if (!dep) {
|
|
74
|
-
dep = /* @__PURE__ */ new Set();
|
|
75
|
-
depsMap.set(key, dep);
|
|
76
|
-
}
|
|
77
|
-
if (!dep.has(activeEffect)) {
|
|
78
|
-
dep.add(activeEffect);
|
|
79
|
-
activeEffect.deps.push(dep);
|
|
80
|
-
}
|
|
81
|
-
}
|
|
82
|
-
function trigger(target, key) {
|
|
83
|
-
const depsMap = targetMap.get(target);
|
|
84
|
-
if (!depsMap) return;
|
|
85
|
-
const effects = depsMap.get(key);
|
|
86
|
-
if (!effects) return;
|
|
87
|
-
const effectsToRun = /* @__PURE__ */ new Set();
|
|
88
|
-
effects.forEach((ef) => {
|
|
89
|
-
if (ef !== activeEffect) effectsToRun.add(ef);
|
|
90
|
-
});
|
|
91
|
-
effectsToRun.forEach((ef) => {
|
|
92
|
-
if (ef.scheduler) ef.scheduler();
|
|
93
|
-
else ef();
|
|
94
|
-
});
|
|
95
|
-
}
|
|
96
|
-
function trackEffects(dep) {
|
|
97
|
-
if (!activeEffect) return;
|
|
98
|
-
if (!dep.has(activeEffect)) {
|
|
99
|
-
dep.add(activeEffect);
|
|
100
|
-
activeEffect.deps.push(dep);
|
|
101
|
-
}
|
|
102
|
-
}
|
|
103
|
-
function triggerEffects(dep) {
|
|
104
|
-
dep.forEach((ef) => {
|
|
105
|
-
if (ef.scheduler) ef.scheduler();
|
|
106
|
-
else ef();
|
|
107
|
-
});
|
|
108
|
-
}
|
|
109
|
-
|
|
110
|
-
//#endregion
|
|
111
|
-
//#region src/reactivity/computed.ts
|
|
112
|
-
function computed(getterOrOptions) {
|
|
113
|
-
let getter;
|
|
114
|
-
let setter;
|
|
115
|
-
const onlyGetter = typeof getterOrOptions === "function";
|
|
116
|
-
if (onlyGetter) {
|
|
117
|
-
getter = getterOrOptions;
|
|
118
|
-
setter = () => {
|
|
119
|
-
throw new Error("Computed value is readonly");
|
|
120
|
-
};
|
|
121
|
-
} else {
|
|
122
|
-
getter = getterOrOptions.get;
|
|
123
|
-
setter = getterOrOptions.set;
|
|
124
|
-
}
|
|
125
|
-
let value;
|
|
126
|
-
let dirty = true;
|
|
127
|
-
let runner;
|
|
128
|
-
const obj = {
|
|
129
|
-
get value() {
|
|
130
|
-
if (dirty) {
|
|
131
|
-
value = runner();
|
|
132
|
-
dirty = false;
|
|
133
|
-
}
|
|
134
|
-
track(obj, "value");
|
|
135
|
-
return value;
|
|
136
|
-
},
|
|
137
|
-
set value(newValue) {
|
|
138
|
-
setter(newValue);
|
|
139
|
-
}
|
|
140
|
-
};
|
|
141
|
-
runner = effect(getter, {
|
|
142
|
-
lazy: true,
|
|
143
|
-
scheduler: () => {
|
|
144
|
-
if (!dirty) {
|
|
145
|
-
dirty = true;
|
|
146
|
-
trigger(obj, "value");
|
|
147
|
-
}
|
|
148
|
-
}
|
|
149
|
-
});
|
|
150
|
-
return onlyGetter ? obj : obj;
|
|
151
|
-
}
|
|
152
|
-
|
|
153
|
-
//#endregion
|
|
154
|
-
//#region src/reactivity/reactive.ts
|
|
155
|
-
const reactiveMap = /* @__PURE__ */ new WeakMap();
|
|
156
|
-
const rawMap = /* @__PURE__ */ new WeakMap();
|
|
157
|
-
const rawRootMap = /* @__PURE__ */ new WeakMap();
|
|
158
|
-
let ReactiveFlags = /* @__PURE__ */ function(ReactiveFlags$1) {
|
|
159
|
-
ReactiveFlags$1["IS_REACTIVE"] = "__r_isReactive";
|
|
160
|
-
ReactiveFlags$1["RAW"] = "__r_raw";
|
|
161
|
-
return ReactiveFlags$1;
|
|
162
|
-
}({});
|
|
163
|
-
function isObject(value) {
|
|
164
|
-
return typeof value === "object" && value !== null;
|
|
165
|
-
}
|
|
166
|
-
const VERSION_KEY = Symbol("wevu.version");
|
|
167
|
-
const mutableHandlers = {
|
|
168
|
-
get(target, key, receiver) {
|
|
169
|
-
if (key === ReactiveFlags.IS_REACTIVE) return true;
|
|
170
|
-
if (key === ReactiveFlags.RAW) return target;
|
|
171
|
-
const res = Reflect.get(target, key, receiver);
|
|
172
|
-
track(target, key);
|
|
173
|
-
if (isObject(res)) {
|
|
174
|
-
const child = res;
|
|
175
|
-
const parentRoot = rawRootMap.get(target) ?? target;
|
|
176
|
-
if (!rawRootMap.has(child)) rawRootMap.set(child, parentRoot);
|
|
177
|
-
return reactive(res);
|
|
178
|
-
}
|
|
179
|
-
return res;
|
|
180
|
-
},
|
|
181
|
-
set(target, key, value, receiver) {
|
|
182
|
-
const oldValue = Reflect.get(target, key, receiver);
|
|
183
|
-
const result = Reflect.set(target, key, value, receiver);
|
|
184
|
-
if (!Object.is(oldValue, value)) {
|
|
185
|
-
trigger(target, key);
|
|
186
|
-
trigger(target, VERSION_KEY);
|
|
187
|
-
const root = rawRootMap.get(target);
|
|
188
|
-
if (root && root !== target) trigger(root, VERSION_KEY);
|
|
189
|
-
}
|
|
190
|
-
return result;
|
|
191
|
-
},
|
|
192
|
-
deleteProperty(target, key) {
|
|
193
|
-
const hadKey = Object.prototype.hasOwnProperty.call(target, key);
|
|
194
|
-
const result = Reflect.deleteProperty(target, key);
|
|
195
|
-
if (hadKey && result) {
|
|
196
|
-
trigger(target, key);
|
|
197
|
-
trigger(target, VERSION_KEY);
|
|
198
|
-
const root = rawRootMap.get(target);
|
|
199
|
-
if (root && root !== target) trigger(root, VERSION_KEY);
|
|
200
|
-
}
|
|
201
|
-
return result;
|
|
202
|
-
},
|
|
203
|
-
ownKeys(target) {
|
|
204
|
-
track(target, Symbol.iterator);
|
|
205
|
-
track(target, VERSION_KEY);
|
|
206
|
-
return Reflect.ownKeys(target);
|
|
207
|
-
}
|
|
208
|
-
};
|
|
209
|
-
function reactive(target) {
|
|
210
|
-
if (!isObject(target)) return target;
|
|
211
|
-
const existingProxy = reactiveMap.get(target);
|
|
212
|
-
if (existingProxy) return existingProxy;
|
|
213
|
-
if (target[ReactiveFlags.IS_REACTIVE]) return target;
|
|
214
|
-
const proxy = new Proxy(target, mutableHandlers);
|
|
215
|
-
reactiveMap.set(target, proxy);
|
|
216
|
-
rawMap.set(proxy, target);
|
|
217
|
-
if (!rawRootMap.has(target)) rawRootMap.set(target, target);
|
|
218
|
-
return proxy;
|
|
219
|
-
}
|
|
220
|
-
function isReactive(value) {
|
|
221
|
-
return Boolean(value && value[ReactiveFlags.IS_REACTIVE]);
|
|
222
|
-
}
|
|
223
|
-
function toRaw(observed) {
|
|
224
|
-
return observed?.[ReactiveFlags.RAW] ?? observed;
|
|
225
|
-
}
|
|
226
|
-
function convertToReactive(value) {
|
|
227
|
-
return isObject(value) ? reactive(value) : value;
|
|
228
|
-
}
|
|
229
|
-
/**
|
|
230
|
-
* Establish a dependency on the whole reactive object "version".
|
|
231
|
-
* This lets effects react to any change on the object without deep traverse.
|
|
232
|
-
*/
|
|
233
|
-
function touchReactive(target) {
|
|
234
|
-
track(toRaw(target), VERSION_KEY);
|
|
235
|
-
}
|
|
236
|
-
|
|
237
|
-
//#endregion
|
|
238
|
-
//#region src/reactivity/ref.ts
|
|
239
|
-
function isRef(value) {
|
|
240
|
-
return Boolean(value && typeof value === "object" && "value" in value);
|
|
241
|
-
}
|
|
242
|
-
var RefImpl = class {
|
|
243
|
-
_value;
|
|
244
|
-
_rawValue;
|
|
245
|
-
dep;
|
|
246
|
-
constructor(value) {
|
|
247
|
-
this._rawValue = value;
|
|
248
|
-
this._value = convertToReactive(value);
|
|
249
|
-
}
|
|
250
|
-
get value() {
|
|
251
|
-
if (!this.dep) this.dep = /* @__PURE__ */ new Set();
|
|
252
|
-
trackEffects(this.dep);
|
|
253
|
-
return this._value;
|
|
254
|
-
}
|
|
255
|
-
set value(newValue) {
|
|
256
|
-
if (!Object.is(newValue, this._rawValue)) {
|
|
257
|
-
this._rawValue = newValue;
|
|
258
|
-
this._value = convertToReactive(newValue);
|
|
259
|
-
if (this.dep) triggerEffects(this.dep);
|
|
260
|
-
}
|
|
261
|
-
}
|
|
262
|
-
};
|
|
263
|
-
function ref(value) {
|
|
264
|
-
if (isRef(value)) return value;
|
|
265
|
-
return new RefImpl(value);
|
|
266
|
-
}
|
|
267
|
-
function unref(value) {
|
|
268
|
-
return isRef(value) ? value.value : value;
|
|
269
|
-
}
|
|
270
|
-
|
|
271
|
-
//#endregion
|
|
272
|
-
Object.defineProperty(exports, 'computed', {
|
|
273
|
-
enumerable: true,
|
|
274
|
-
get: function () {
|
|
275
|
-
return computed;
|
|
276
|
-
}
|
|
277
|
-
});
|
|
278
|
-
Object.defineProperty(exports, 'effect', {
|
|
279
|
-
enumerable: true,
|
|
280
|
-
get: function () {
|
|
281
|
-
return effect;
|
|
282
|
-
}
|
|
283
|
-
});
|
|
284
|
-
Object.defineProperty(exports, 'isObject', {
|
|
285
|
-
enumerable: true,
|
|
286
|
-
get: function () {
|
|
287
|
-
return isObject;
|
|
288
|
-
}
|
|
289
|
-
});
|
|
290
|
-
Object.defineProperty(exports, 'isReactive', {
|
|
291
|
-
enumerable: true,
|
|
292
|
-
get: function () {
|
|
293
|
-
return isReactive;
|
|
294
|
-
}
|
|
295
|
-
});
|
|
296
|
-
Object.defineProperty(exports, 'isRef', {
|
|
297
|
-
enumerable: true,
|
|
298
|
-
get: function () {
|
|
299
|
-
return isRef;
|
|
300
|
-
}
|
|
301
|
-
});
|
|
302
|
-
Object.defineProperty(exports, 'nextTick', {
|
|
303
|
-
enumerable: true,
|
|
304
|
-
get: function () {
|
|
305
|
-
return nextTick;
|
|
306
|
-
}
|
|
307
|
-
});
|
|
308
|
-
Object.defineProperty(exports, 'queueJob', {
|
|
309
|
-
enumerable: true,
|
|
310
|
-
get: function () {
|
|
311
|
-
return queueJob;
|
|
312
|
-
}
|
|
313
|
-
});
|
|
314
|
-
Object.defineProperty(exports, 'reactive', {
|
|
315
|
-
enumerable: true,
|
|
316
|
-
get: function () {
|
|
317
|
-
return reactive;
|
|
318
|
-
}
|
|
319
|
-
});
|
|
320
|
-
Object.defineProperty(exports, 'ref', {
|
|
321
|
-
enumerable: true,
|
|
322
|
-
get: function () {
|
|
323
|
-
return ref;
|
|
324
|
-
}
|
|
325
|
-
});
|
|
326
|
-
Object.defineProperty(exports, 'stop', {
|
|
327
|
-
enumerable: true,
|
|
328
|
-
get: function () {
|
|
329
|
-
return stop;
|
|
330
|
-
}
|
|
331
|
-
});
|
|
332
|
-
Object.defineProperty(exports, 'toRaw', {
|
|
333
|
-
enumerable: true,
|
|
334
|
-
get: function () {
|
|
335
|
-
return toRaw;
|
|
336
|
-
}
|
|
337
|
-
});
|
|
338
|
-
Object.defineProperty(exports, 'touchReactive', {
|
|
339
|
-
enumerable: true,
|
|
340
|
-
get: function () {
|
|
341
|
-
return touchReactive;
|
|
342
|
-
}
|
|
343
|
-
});
|
|
344
|
-
Object.defineProperty(exports, 'unref', {
|
|
345
|
-
enumerable: true,
|
|
346
|
-
get: function () {
|
|
347
|
-
return unref;
|
|
348
|
-
}
|
|
349
|
-
});
|