@formvk/reactive 0.0.0-stage → 1.0.0

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/CHANGELOG.md ADDED
@@ -0,0 +1,7 @@
1
+ # @formvk/reactive
2
+
3
+ ## 1.0.0
4
+
5
+ ### Major Changes
6
+
7
+ - 65c066c: 添加readme.md文档
package/README.md CHANGED
@@ -1,3 +1,94 @@
1
- # Temporary Holding Version
1
+ # @formvk/reactive
2
2
 
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
3
+ Reactive runtime built on `@vue/reactivity`. On top of Vue reactivity it adds observable change tracking with paths (`observe`), scheduling (`batch` / `action`), and standard-decorator support (`@observable`, `@computed`, `@shallowRef`).
4
+
5
+ ## Install
6
+
7
+ ```bash
8
+ pnpm add @formvk/reactive
9
+ ```
10
+
11
+ ## Usage
12
+
13
+ `observable` creates an object whose writes are reported to `observe` with a change path:
14
+
15
+ ```ts
16
+ import { observable, observe } from '@formvk/reactive'
17
+
18
+ const state = observable({ count: 0, step: 1 })
19
+
20
+ const dispose = observe(state, change => {
21
+ console.log(change.path, change.value)
22
+ })
23
+
24
+ state.count += state.step
25
+ dispose()
26
+ ```
27
+
28
+ Use `reactive` / `shallowRef` / `shallow` with `autorun` when you only need dependency tracking:
29
+
30
+ ```ts
31
+ import { autorun, reactive } from '@formvk/reactive'
32
+
33
+ const state = reactive({ count: 0 })
34
+
35
+ const stop = autorun(() => {
36
+ console.log(state.count)
37
+ })
38
+
39
+ state.count++
40
+ stop()
41
+ ```
42
+
43
+ Decorators (TypeScript 5 standard decorators):
44
+
45
+ ```ts
46
+ import { computed, observable, shallowRef } from '@formvk/reactive'
47
+
48
+ class Counter {
49
+ @observable accessor count = 0
50
+
51
+ @shallowRef accessor items: string[] = []
52
+
53
+ @computed get doubled() {
54
+ return this.count * 2
55
+ }
56
+ }
57
+ ```
58
+
59
+ Batch and action group writes so reactions run once:
60
+
61
+ ```ts
62
+ import { action, batch, reactive } from '@formvk/reactive'
63
+
64
+ const state = reactive({ a: 0, b: 0 })
65
+
66
+ batch(() => {
67
+ state.a = 1
68
+ state.b = 2
69
+ })
70
+
71
+ const update = action(() => {
72
+ state.a += 1
73
+ })
74
+ update()
75
+ ```
76
+
77
+ ## API
78
+
79
+ - **Reactive sources** — `observable` (trackable by `observe`), `reactive`, `shallow`, `shallowRef`, `computed`.
80
+ - **Observation** — `observe`, `autorun`, `reaction`, `Tracker`.
81
+ - **Scheduling** — `batch`, `batch.scope`, `batch.endpoint`, `action`, `action.scope`, `untracked`.
82
+ - **Interop** — `toJS`, `contains`, `isObservable`, `isReactive`, `registerSkip`.
83
+ - **Types** — `IChange`, `Observer`, `DataChange`, `Dispose`, `IReactionOptions`, `Boundary`, `IAction`, `IBatch`.
84
+
85
+ Only objects created with `observable()` can be passed to `observe`; `reactive`, `shallow`, `shallowRef` and `computed` are plain Vue reactivity and should be watched with `autorun` / `reaction`.
86
+
87
+ ## Documentation
88
+
89
+ - Reactivity guide: https://formvk.github.io/core/guide/reactivity
90
+ - React bindings: https://formvk.github.io/core/api/react
91
+
92
+ ## License
93
+
94
+ MIT
@@ -0,0 +1,186 @@
1
+ import { isReactive } from '@vue/reactivity';
2
+ import { ShallowRef } from '@vue/reactivity';
3
+
4
+ /** action = batch + untrack:合并通知,同时不收集执行期间的响应式读取 */
5
+ export declare const action: IAction;
6
+
7
+ declare type AnyFunction = (...args: any[]) => any;
8
+
9
+ /**
10
+ * 自动运行:立即执行 tracker,并追踪其中读取的响应式数据,
11
+ * 任意依赖变化都会整体重跑 tracker。
12
+ */
13
+ export declare function autorun(tracker: () => void): Dispose;
14
+
15
+ /** 批量执行:合并批次内的响应式写入,批次结束时统一刷新 reaction */
16
+ export declare const batch: IBatch;
17
+
18
+ export declare type BindFunction<F = (...args: any[]) => any> = (callback?: F, context?: any) => F;
19
+
20
+ /** 既是边界函数(直接调用),也可作为类成员装饰器使用 */
21
+ export declare type Boundary = {
22
+ <F extends AnyFunction>(value: F, context: ClassMethodDecoratorContext | ClassGetterDecoratorContext | ClassSetterDecoratorContext): F;
23
+ (value: undefined, context: ClassFieldDecoratorContext): (initialValue: any) => any;
24
+ <T>(callback?: () => T): T;
25
+ bound: BindFunction;
26
+ };
27
+
28
+ /**
29
+ * 创建 Vue 计算属性,或作为 getter 装饰器按实例缓存计算结果。
30
+ * 纯 Vue 响应式,不可被 observe。
31
+ */
32
+ export declare const computed: IComputed;
33
+
34
+ /** computed 函数形态的只读返回值 */
35
+ export declare interface ComputedValue<T> {
36
+ readonly value: T;
37
+ }
38
+
39
+ /** 判断 property 是否就是 target 自身或其后代节点 */
40
+ export declare function contains(target: any, property: any): boolean;
41
+
42
+ /** observe 回调中的变更描述,与 formily 的 DataChange 对齐 */
43
+ export declare type DataChange = IChange;
44
+
45
+ export declare type Dispose = () => void;
46
+
47
+ export declare interface IAction extends Boundary {
48
+ scope: Boundary;
49
+ }
50
+
51
+ export declare interface IBatch extends IAction {
52
+ endpoint: (callback?: () => void) => void;
53
+ }
54
+
55
+ export declare interface IChange {
56
+ type: 'add' | 'set' | 'delete';
57
+ key: PropertyKey;
58
+ value?: any;
59
+ oldValue?: any;
60
+ /** 内层 Vue reactive 对象,即变更发生的那个对象 */
61
+ target: any;
62
+ /** 相对当前观察者视角的路径 */
63
+ path: PropertyKey[];
64
+ }
65
+
66
+ export declare interface IComputed {
67
+ <T>(getter: (this: any) => T, context: ClassGetterDecoratorContext): (this: any) => T;
68
+ <T>(getter: () => T): ComputedValue<T>;
69
+ <T>(options: {
70
+ get: () => T;
71
+ }): ComputedValue<T>;
72
+ <T>(options: {
73
+ get: () => T;
74
+ set: (value: T) => void;
75
+ }): WritableComputedValue<T>;
76
+ }
77
+
78
+ export declare interface IObservable {
79
+ (value: ClassAccessorDecoratorTarget<any, any>, context: ClassAccessorDecoratorContext): ClassAccessorDecoratorResult<any, any>;
80
+ (value: undefined, context: ClassFieldDecoratorContext): (initialValue: any) => any;
81
+ <T>(source: T): T;
82
+ }
83
+
84
+ export declare interface IReactionOptions<T> {
85
+ /** 返回 true 表示新旧值相等,不触发 subscriber */
86
+ equals?: (oldValue: T, newValue: T) => boolean;
87
+ /** 初始化后立即触发一次 subscriber */
88
+ fireImmediately?: boolean;
89
+ }
90
+
91
+ export declare interface IReactive {
92
+ (value: ClassAccessorDecoratorTarget<any, any>, context: ClassAccessorDecoratorContext): ClassAccessorDecoratorResult<any, any>;
93
+ (value: undefined, context: ClassFieldDecoratorContext): (initialValue: any) => any;
94
+ <T>(source: T): T;
95
+ }
96
+
97
+ export declare interface IShallow {
98
+ (value: ClassAccessorDecoratorTarget<any, any>, context: ClassAccessorDecoratorContext): ClassAccessorDecoratorResult<any, any>;
99
+ (value: undefined, context: ClassFieldDecoratorContext): (initialValue: any) => any;
100
+ <T>(source: T): T;
101
+ }
102
+
103
+ export declare interface IShallowRef {
104
+ (value: ClassAccessorDecoratorTarget<any, any>, context: ClassAccessorDecoratorContext): ClassAccessorDecoratorResult<any, any>;
105
+ (value: undefined, context: ClassFieldDecoratorContext): (initialValue: any) => any;
106
+ <T>(value: T): ShallowRef<T>;
107
+ }
108
+
109
+ /** 判断值是否是 observable(wrap 出的 formvk 代理;纯 Vue reactive 不在此列) */
110
+ export declare function isObservable(value: any): boolean;
111
+
112
+ export { isReactive }
113
+
114
+ /**
115
+ * 创建可被 observe 的响应式对象(formvk 外层代理 + Vue 深响应式),
116
+ * 同时支持 field / accessor 装饰器。
117
+ * 这是唯一能被 observe 监听的入口;只需要 autorun 追踪时请改用 reactive/shallowRef/shallow。
118
+ */
119
+ export declare const observable: IObservable;
120
+
121
+ /** 监听对象所有写操作,返回 dispose;仅支持 observable() 创建的对象 */
122
+ export declare function observe<T extends object>(target: T, observer: Observer, deep?: boolean): () => void;
123
+
124
+ export declare type Observer = (change: IChange) => void;
125
+
126
+ /**
127
+ * 自定义运行:tracker 只负责求值并收集依赖,
128
+ * 依赖变化后重新求值,值发生变更才调用 subscriber。
129
+ */
130
+ export declare function reaction<T>(tracker: () => T, subscriber?: (value: T, oldValue: T) => void, options?: IReactionOptions<T>): Dispose;
131
+
132
+ /**
133
+ * 创建纯 Vue 响应式对象(深响应),同时支持 field / accessor 装饰器。
134
+ * 与 observable 的区别:不包 formvk 外层代理,没有变更路径传播,不能被 observe 监听。
135
+ */
136
+ export declare const reactive: IReactive;
137
+
138
+ /**
139
+ * 注册“跳过包装”的判定,可注册多个,任一命中即跳过;返回销毁函数。
140
+ * 命中的值不会生成外层 proxy,元素本身及其嵌套结构保持原始引用。
141
+ */
142
+ export declare function registerSkip(matcher: SkipMatcher): () => void;
143
+
144
+ /**
145
+ * 创建纯 Vue 浅响应式对象,同时支持 field / accessor 装饰器。
146
+ * 不包 formvk 外层代理,不可被 observe,变更请用 autorun 监听。
147
+ */
148
+ export declare const shallow: IShallow;
149
+
150
+ /**
151
+ * 浅响应式盒子(Vue shallowRef):只有整体替换 .value 才触发通知,
152
+ * 盒子内对象的深层变更不具响应性。不可被 observe,变更请用 autorun 监听。
153
+ */
154
+ export declare const shallowRef: IShallowRef;
155
+
156
+ export declare type SkipMatcher = (value: object) => boolean;
157
+
158
+ /** 把可观察/响应式对象深拷贝为普通对象,其余值原样返回 */
159
+ export declare function toJS<T>(values: T): T;
160
+
161
+ /**
162
+ * 手动追踪器:track 时立即执行 view 并收集其中读取的响应式依赖,
163
+ * 依赖变化时只触发 scheduler 通知外部,不会自动重跑 view,
164
+ * 由外部(如 React 的 forceUpdate)决定何时再次调用 track。
165
+ * 主要供 UI 框架在渲染期手动接管追踪时机。
166
+ */
167
+ export declare class Tracker {
168
+ private runner;
169
+ private view;
170
+ private result;
171
+ constructor(scheduler?: () => void);
172
+ /** 执行 view 并重新收集依赖,返回本次执行结果;可重复调用,依赖以最近一次为准 */
173
+ track<T>(view: () => T): T;
174
+ /** 停止追踪并释放全部响应式依赖 */
175
+ dispose: Dispose;
176
+ }
177
+
178
+ /** 在回调执行期间暂停依赖收集,也支持 untracked.bound 绑定上下文 */
179
+ export declare const untracked: Boundary;
180
+
181
+ /** computed 函数形态的可写返回值 */
182
+ export declare interface WritableComputedValue<T> {
183
+ value: T;
184
+ }
185
+
186
+ export { }
package/dist/index.js ADDED
@@ -0,0 +1,530 @@
1
+ import { computed as computed$1, effect, isReactive, isRef, pauseTracking, reactive as reactive$1, resetTracking, shallowReactive, shallowRef as shallowRef$1, stop, toRaw, unref } from "@vue/reactivity";
2
+ // src/decorator.ts
3
+ /**
4
+ * accessor 装饰器通用工厂:字段值存进 createBox 返回的盒子,读写都经过盒子,
5
+ * 因此重新赋值也能保持响应式(普通 field 装饰器只能改写初始值)。
6
+ * normalize 用于写入前归一化(如把对象包成响应式代理),默认原样透传。
7
+ *
8
+ * 懒加载:构造期只创建轻量哨兵保存初始值,不调用 createBox;
9
+ * 直到该字段第一次被读/写时才真正创建响应式盒子并回写私有槽,之后一直复用。
10
+ *
11
+ * 实现约束:
12
+ * 1. 用 WeakSet 识别哨兵而非 symbol 品牌——盒子可能是 Vue Proxy,属性访问会触发
13
+ * get trap 并污染依赖收集,WeakSet 按对象 identity 判定,零 trap 副作用;
14
+ * 2. WeakSet 的 key 必须是槽位对象而不能是类实例:实例首次作为 WeakCollection key
15
+ * 会被 V8 附加 identity hash 并触发 map transition,使实例隐藏类失稳、字段访问
16
+ * 内联缓存多态化,实测全激活路径反而慢 4~18 倍;
17
+ * 3. 槽位替换后哨兵失去引用即可被 GC,WeakSet 不造成泄漏。
18
+ *
19
+ * 注意:field 装饰器没有读写拦截点,无法懒加载,仍在构造期即时转换。
20
+ */
21
+ function accessorDecorator(createBox, normalize = (value) => value) {
22
+ const lazySlots = /* @__PURE__ */ new WeakSet();
23
+ return (target, _context) => ({
24
+ init(initialValue) {
25
+ const slot = { raw: initialValue };
26
+ lazySlots.add(slot);
27
+ return slot;
28
+ },
29
+ get() {
30
+ const slot = target.get.call(this);
31
+ if (lazySlots.has(slot)) {
32
+ const box = createBox(normalize(slot.raw));
33
+ target.set.call(this, box);
34
+ return box.value;
35
+ }
36
+ return slot.value;
37
+ },
38
+ set(value) {
39
+ const slot = target.get.call(this);
40
+ if (lazySlots.has(slot)) {
41
+ target.set.call(this, createBox(normalize(value)));
42
+ return;
43
+ }
44
+ slot.value = normalize(value);
45
+ }
46
+ });
47
+ }
48
+ // src/internals.ts
49
+ var SKIP_CTORS = [
50
+ Date,
51
+ RegExp,
52
+ Map,
53
+ Set,
54
+ WeakMap,
55
+ WeakSet,
56
+ Promise
57
+ ];
58
+ /** 内层 Vue reactive proxy -> 观察者集合 */
59
+ var handlerMap = /* @__PURE__ */ new WeakMap();
60
+ /** 子 -> 所有父 */
61
+ var parentMap = /* @__PURE__ */ new WeakMap();
62
+ /** 子 + 父 -> 在父里的 key */
63
+ var parentKeyMap = /* @__PURE__ */ new WeakMap();
64
+ /** 内层 proxy -> 外层 proxy */
65
+ var proxyCache = /* @__PURE__ */ new WeakMap();
66
+ /** 外层 proxy -> 内层 proxy */
67
+ var reverseCache = /* @__PURE__ */ new WeakMap();
68
+ var skipMatchers = /* @__PURE__ */ new Set();
69
+ /**
70
+ * 注册“跳过包装”的判定,可注册多个,任一命中即跳过;返回销毁函数。
71
+ * 命中的值不会生成外层 proxy,元素本身及其嵌套结构保持原始引用。
72
+ */
73
+ function registerSkip(matcher) {
74
+ skipMatchers.add(matcher);
75
+ return () => {
76
+ skipMatchers.delete(matcher);
77
+ };
78
+ }
79
+ /** React 元素、Vue VNode 以及自定义跳过判定 */
80
+ function shouldSkip(v) {
81
+ if (v === null || typeof v !== "object") return false;
82
+ if ("$$typeof" in v && "_owner" in v) return true;
83
+ if (v.__v_isVNode === true) return true;
84
+ for (const matcher of skipMatchers) if (matcher(v)) return true;
85
+ return false;
86
+ }
87
+ function canProxy(v) {
88
+ if (v === null || typeof v !== "object") return false;
89
+ if (isRef(v)) return false;
90
+ if (v.__v_skip) return false;
91
+ if (shouldSkip(v)) return false;
92
+ for (const C of SKIP_CTORS) if (v instanceof C) return false;
93
+ return true;
94
+ }
95
+ function addParent(childVueProxy, parentVueProxy, key) {
96
+ let parents = parentMap.get(childVueProxy);
97
+ if (!parents) {
98
+ parents = /* @__PURE__ */ new Set();
99
+ parentMap.set(childVueProxy, parents);
100
+ }
101
+ parents.add(parentVueProxy);
102
+ let keys = parentKeyMap.get(childVueProxy);
103
+ if (!keys) {
104
+ keys = /* @__PURE__ */ new Map();
105
+ parentKeyMap.set(childVueProxy, keys);
106
+ }
107
+ keys.set(parentVueProxy, key);
108
+ }
109
+ function wrap(vueProxy, parentVueProxy, parentKey, shallow = false) {
110
+ if (!canProxy(vueProxy)) return vueProxy;
111
+ let proxy = proxyCache.get(vueProxy);
112
+ if (!proxy) {
113
+ proxy = new Proxy(vueProxy, {
114
+ get(target, key, receiver) {
115
+ const raw = Reflect.get(target, key, receiver);
116
+ if (key === "__v_raw") return raw;
117
+ const value = unref(raw);
118
+ if (value !== raw) return value;
119
+ if (shouldSkip(value)) return toRaw(value);
120
+ if (!shallow && canProxy(value)) return wrap(value, target, key);
121
+ return value;
122
+ },
123
+ set(target, key, value) {
124
+ const raw = toRaw(target);
125
+ const had = Object.prototype.hasOwnProperty.call(raw, key);
126
+ const oldValue = raw[key];
127
+ const result = Reflect.set(target, key, value);
128
+ if (result && !Object.is(oldValue, value)) notifyDeep(target, {
129
+ type: had ? "set" : "add",
130
+ key,
131
+ value,
132
+ oldValue,
133
+ target,
134
+ path: []
135
+ });
136
+ return result;
137
+ },
138
+ deleteProperty(target, key) {
139
+ const raw = toRaw(target);
140
+ const had = Object.prototype.hasOwnProperty.call(raw, key);
141
+ const oldValue = raw[key];
142
+ const result = Reflect.deleteProperty(target, key);
143
+ if (had && result) notifyDeep(target, {
144
+ type: "delete",
145
+ key,
146
+ value: void 0,
147
+ oldValue,
148
+ target,
149
+ path: []
150
+ });
151
+ return result;
152
+ }
153
+ });
154
+ proxyCache.set(vueProxy, proxy);
155
+ reverseCache.set(proxy, vueProxy);
156
+ }
157
+ if (parentVueProxy) addParent(vueProxy, parentVueProxy, parentKey);
158
+ return proxy;
159
+ }
160
+ function notifyDeep(sourceVueProxy, change) {
161
+ const own = handlerMap.get(sourceVueProxy);
162
+ if (own) own.forEach((e) => e.fn({
163
+ ...change,
164
+ path: []
165
+ }));
166
+ const visited = /* @__PURE__ */ new Set([sourceVueProxy]);
167
+ const queue = [];
168
+ const seedParents = parentMap.get(sourceVueProxy);
169
+ if (seedParents) for (const p of seedParents) {
170
+ const k = parentKeyMap.get(sourceVueProxy)?.get(p);
171
+ if (k !== void 0) queue.push({
172
+ node: p,
173
+ path: [k]
174
+ });
175
+ }
176
+ while (queue.length) {
177
+ const { node, path } = queue.shift();
178
+ if (visited.has(node)) continue;
179
+ visited.add(node);
180
+ const set = handlerMap.get(node);
181
+ if (set) set.forEach((e) => {
182
+ if (e.deep) e.fn({
183
+ ...change,
184
+ path: [...path]
185
+ });
186
+ });
187
+ const parents = parentMap.get(node);
188
+ if (parents) for (const p of parents) {
189
+ const k = parentKeyMap.get(node)?.get(p);
190
+ if (k !== void 0) queue.push({
191
+ node: p,
192
+ path: [k, ...path]
193
+ });
194
+ }
195
+ }
196
+ }
197
+ // src/observable.ts
198
+ var REACTIVE_TAGS = /* @__PURE__ */ new Set([
199
+ "[object Object]",
200
+ "[object Array]",
201
+ "[object Map]",
202
+ "[object Set]",
203
+ "[object WeakMap]",
204
+ "[object WeakSet]"
205
+ ]);
206
+ function isReactiveTarget(value) {
207
+ if (value === null || typeof value !== "object") return false;
208
+ if (isRef(value)) return false;
209
+ if (value.__v_skip) return false;
210
+ if (shouldSkip(value)) return false;
211
+ return REACTIVE_TAGS.has(Object.prototype.toString.call(value));
212
+ }
213
+ function toObservable(source) {
214
+ if (!isReactiveTarget(source)) return source;
215
+ return wrap(reactive$1(source));
216
+ }
217
+ function observableImpl(source, context) {
218
+ if (!context) return toObservable(source);
219
+ if (context.kind === "field") return (initialValue) => toObservable(initialValue);
220
+ if (context.kind === "accessor") return accessorDecorator((value) => toObservable({ value }))(source, context);
221
+ return source;
222
+ }
223
+ /**
224
+ * 创建可被 observe 的响应式对象(formvk 外层代理 + Vue 深响应式),
225
+ * 同时支持 field / accessor 装饰器。
226
+ * 这是唯一能被 observe 监听的入口;只需要 autorun 追踪时请改用 reactive/shallowRef/shallow。
227
+ */
228
+ var observable = observableImpl;
229
+ // src/reactive.ts
230
+ /** 纯 Vue 深响应式:只服务 autorun/effect,不进入 formvk 代理层,不可被 observe */
231
+ function toReactive(source) {
232
+ if (source === null || typeof source !== "object") return source;
233
+ return reactive$1(source);
234
+ }
235
+ function reactiveImpl(value, context) {
236
+ if (!context) return toReactive(value);
237
+ if (context.kind === "field") return (initialValue) => toReactive(initialValue);
238
+ if (context.kind === "accessor") return accessorDecorator((initialValue) => toReactive({ value: initialValue }))(value, context);
239
+ return value;
240
+ }
241
+ /**
242
+ * 创建纯 Vue 响应式对象(深响应),同时支持 field / accessor 装饰器。
243
+ * 与 observable 的区别:不包 formvk 外层代理,没有变更路径传播,不能被 observe 监听。
244
+ */
245
+ var reactive = reactiveImpl;
246
+ // src/shallowRef.ts
247
+ function shallowRefImpl(value, context) {
248
+ if (!context) return shallowRef$1(value);
249
+ if (context.kind === "accessor") return accessorDecorator((initialValue) => shallowRef$1(initialValue))(value, context);
250
+ return value;
251
+ }
252
+ /**
253
+ * 浅响应式盒子(Vue shallowRef):只有整体替换 .value 才触发通知,
254
+ * 盒子内对象的深层变更不具响应性。不可被 observe,变更请用 autorun 监听。
255
+ */
256
+ var shallowRef = shallowRefImpl;
257
+ // src/shallow.ts
258
+ /** 纯 Vue 浅响应式:仅顶层属性变化触发通知,嵌套值保持原始引用 */
259
+ function toShallow(source) {
260
+ if (source === null || typeof source !== "object") return source;
261
+ return shallowReactive(source);
262
+ }
263
+ function shallowImpl(value, context) {
264
+ if (!context) return toShallow(value);
265
+ if (context.kind === "field") return (initialValue) => toShallow(initialValue);
266
+ if (context.kind === "accessor") return accessorDecorator((initialValue) => toShallow({ value: initialValue }))(value, context);
267
+ return value;
268
+ }
269
+ /**
270
+ * 创建纯 Vue 浅响应式对象,同时支持 field / accessor 装饰器。
271
+ * 不包 formvk 外层代理,不可被 observe,变更请用 autorun 监听。
272
+ */
273
+ var shallow = shallowImpl;
274
+ // src/computed.ts
275
+ function computedImpl(compute, context) {
276
+ if (!context) return computed$1(compute);
277
+ if (context.kind !== "getter") throw new Error("[formvk] computed 只支持 getter 装饰器");
278
+ const cache = /* @__PURE__ */ new WeakMap();
279
+ return function() {
280
+ let result = cache.get(this);
281
+ if (!result) {
282
+ result = computed$1(() => compute.call(this));
283
+ cache.set(this, result);
284
+ }
285
+ return result.value;
286
+ };
287
+ }
288
+ /**
289
+ * 创建 Vue 计算属性,或作为 getter 装饰器按实例缓存计算结果。
290
+ * 纯 Vue 响应式,不可被 observe。
291
+ */
292
+ var computed = computedImpl;
293
+ // src/observe.ts
294
+ /** 监听对象所有写操作,返回 dispose;仅支持 observable() 创建的对象 */
295
+ function observe(target, observer, deep = true) {
296
+ const vueProxy = reverseCache.get(target);
297
+ if (!vueProxy) throw new Error("[formvk] observe 仅支持 observable() 创建的对象;reactive/shallowRef/shallow/computed 的变更请用 autorun 监听");
298
+ let set = handlerMap.get(vueProxy);
299
+ if (!set) {
300
+ set = /* @__PURE__ */ new Set();
301
+ handlerMap.set(vueProxy, set);
302
+ }
303
+ const entry = {
304
+ fn: observer,
305
+ deep
306
+ };
307
+ set.add(entry);
308
+ return () => {
309
+ set.delete(entry);
310
+ };
311
+ }
312
+ // src/batch.ts
313
+ function isDecoratorContext(context) {
314
+ return !!context && typeof context === "object" && typeof context.kind === "string";
315
+ }
316
+ var batchCount = 0;
317
+ var batchScope = false;
318
+ var pendingReactions = /* @__PURE__ */ new Set();
319
+ var pendingScopeReactions = /* @__PURE__ */ new Set();
320
+ var batchEndpoints = /* @__PURE__ */ new Set();
321
+ function runAll(runners) {
322
+ if (runners.size === 0) return;
323
+ const queue = Array.from(runners);
324
+ runners.clear();
325
+ for (const run of queue) run();
326
+ }
327
+ function batchStart() {
328
+ batchCount++;
329
+ }
330
+ function batchEnd() {
331
+ batchCount--;
332
+ if (batchCount === 0) {
333
+ runAll(pendingReactions);
334
+ const endpoints = Array.from(batchEndpoints);
335
+ batchEndpoints.clear();
336
+ for (const endpoint of endpoints) endpoint();
337
+ }
338
+ }
339
+ function batchScopeStart() {
340
+ batchScope = true;
341
+ pendingReactions.forEach((runner) => pendingScopeReactions.add(runner));
342
+ pendingReactions.clear();
343
+ }
344
+ function batchScopeEnd() {
345
+ batchScope = false;
346
+ runAll(pendingScopeReactions);
347
+ }
348
+ /** reaction 的调度入口:非批量状态立即执行,否则延迟到批次结束 */
349
+ function scheduleReaction(runner) {
350
+ if (batchScope) pendingScopeReactions.add(runner);
351
+ else if (batchCount > 0) pendingReactions.add(runner);
352
+ else runner();
353
+ }
354
+ /** 创建在 start / end 之间执行回调的边界函数,可同时作为类成员装饰器 */
355
+ function createBoundary(start, end) {
356
+ function invoke(callback) {
357
+ let result = void 0;
358
+ try {
359
+ start();
360
+ if (typeof callback === "function") result = callback();
361
+ } finally {
362
+ end();
363
+ }
364
+ return result;
365
+ }
366
+ function wrap(callback) {
367
+ return function(...args) {
368
+ return invoke(() => callback.apply(this, args));
369
+ };
370
+ }
371
+ function decorate(callback, context) {
372
+ if (context.kind === "field") return (initialValue) => typeof initialValue === "function" ? wrap(initialValue) : initialValue;
373
+ if (typeof callback !== "function") return callback;
374
+ return wrap(callback);
375
+ }
376
+ const boundary = ((callback, context) => {
377
+ if (isDecoratorContext(context)) return decorate(callback, context);
378
+ return invoke(callback);
379
+ });
380
+ const bound = (callback, context) => ((...args) => invoke(() => callback?.apply(context, args)));
381
+ boundary.bound = bound;
382
+ return boundary;
383
+ }
384
+ var scopeBoundary = createBoundary(batchScopeStart, batchScopeEnd);
385
+ /** 批量执行:合并批次内的响应式写入,批次结束时统一刷新 reaction */
386
+ var batch = Object.assign(createBoundary(batchStart, batchEnd), {
387
+ scope: scopeBoundary,
388
+ endpoint: (callback) => {
389
+ if (typeof callback !== "function") return;
390
+ if (batchCount === 0) callback();
391
+ else batchEndpoints.add(callback);
392
+ }
393
+ });
394
+ // src/autorun.ts
395
+ /**
396
+ * 自动运行:立即执行 tracker,并追踪其中读取的响应式数据,
397
+ * 任意依赖变化都会整体重跑 tracker。
398
+ */
399
+ function autorun(tracker) {
400
+ const runner = effect(tracker, { scheduler: () => scheduleReaction(runner) });
401
+ return () => stop(runner);
402
+ }
403
+ /**
404
+ * 自定义运行:tracker 只负责求值并收集依赖,
405
+ * 依赖变化后重新求值,值发生变更才调用 subscriber。
406
+ */
407
+ function reaction(tracker, subscriber, options) {
408
+ const equals = options?.equals ?? ((oldValue, newValue) => oldValue === newValue);
409
+ let oldValue = void 0;
410
+ let firstRun = true;
411
+ const runner = effect(() => {
412
+ const newValue = tracker();
413
+ if (firstRun) {
414
+ firstRun = false;
415
+ oldValue = newValue;
416
+ return;
417
+ }
418
+ if (equals(oldValue, newValue)) return;
419
+ const prevValue = oldValue;
420
+ oldValue = newValue;
421
+ if (!subscriber) return;
422
+ pauseTracking();
423
+ try {
424
+ subscriber(newValue, prevValue);
425
+ } finally {
426
+ resetTracking();
427
+ }
428
+ }, { scheduler: () => scheduleReaction(runner) });
429
+ if (options?.fireImmediately) subscriber?.(oldValue, oldValue);
430
+ return () => stop(runner);
431
+ }
432
+ // src/tracker.ts
433
+ /**
434
+ * 手动追踪器:track 时立即执行 view 并收集其中读取的响应式依赖,
435
+ * 依赖变化时只触发 scheduler 通知外部,不会自动重跑 view,
436
+ * 由外部(如 React 的 forceUpdate)决定何时再次调用 track。
437
+ * 主要供 UI 框架在渲染期手动接管追踪时机。
438
+ */
439
+ var Tracker = class {
440
+ runner;
441
+ view = () => void 0;
442
+ result;
443
+ constructor(scheduler) {
444
+ this.runner = effect(() => {
445
+ this.result = this.view();
446
+ }, { scheduler: scheduler ?? (() => {}) });
447
+ }
448
+ /** 执行 view 并重新收集依赖,返回本次执行结果;可重复调用,依赖以最近一次为准 */
449
+ track(view) {
450
+ this.view = view;
451
+ this.runner();
452
+ return this.result;
453
+ }
454
+ /** 停止追踪并释放全部响应式依赖 */
455
+ dispose = () => stop(this.runner);
456
+ };
457
+ // src/action.ts
458
+ /** action = batch + untrack:合并通知,同时不收集执行期间的响应式读取 */
459
+ var action = Object.assign(createBoundary(() => {
460
+ batchStart();
461
+ pauseTracking();
462
+ }, () => {
463
+ resetTracking();
464
+ batchEnd();
465
+ }), { scope: createBoundary(() => {
466
+ batchScopeStart();
467
+ pauseTracking();
468
+ }, () => {
469
+ resetTracking();
470
+ batchScopeEnd();
471
+ }) });
472
+ // src/externals.ts
473
+ /** 外层 proxy 统一还原为内层 Vue proxy,便于匹配父子关系;入参已由 contains 保证为非空对象 */
474
+ function normalize(value) {
475
+ return reverseCache.get(value) ?? value;
476
+ }
477
+ /** 判断值是否是 observable(wrap 出的 formvk 代理;纯 Vue reactive 不在此列) */
478
+ function isObservable(value) {
479
+ if (value === null || typeof value !== "object") return false;
480
+ return reverseCache.has(value);
481
+ }
482
+ /** 把可观察/响应式对象深拷贝为普通对象,其余值原样返回 */
483
+ function toJS(values) {
484
+ const visited = /* @__PURE__ */ new WeakSet();
485
+ function convert(value) {
486
+ if (value === null || typeof value !== "object") return value;
487
+ if (!isObservable(value) && !isReactive(value)) return value;
488
+ if (visited.has(value)) return toRaw(value);
489
+ visited.add(value);
490
+ if (Array.isArray(value)) {
491
+ const result = value.map((item) => convert(item));
492
+ visited.delete(value);
493
+ return result;
494
+ }
495
+ const result = {};
496
+ for (const key in value) result[key] = convert(value[key]);
497
+ visited.delete(value);
498
+ return result;
499
+ }
500
+ return convert(values);
501
+ }
502
+ /** 判断 property 是否就是 target 自身或其后代节点 */
503
+ function contains(target, property) {
504
+ if (target === property) return true;
505
+ if (target === null || typeof target !== "object") return false;
506
+ if (property === null || typeof property !== "object") return false;
507
+ const targetNode = normalize(target);
508
+ const propertyNode = normalize(property);
509
+ if (targetNode === propertyNode) return true;
510
+ const visited = /* @__PURE__ */ new Set([propertyNode]);
511
+ const queue = [propertyNode];
512
+ while (queue.length) {
513
+ const node = queue.shift();
514
+ const parents = parentMap.get(node);
515
+ if (!parents) continue;
516
+ for (const parent of parents) {
517
+ if (parent === targetNode) return true;
518
+ if (visited.has(parent)) continue;
519
+ visited.add(parent);
520
+ queue.push(parent);
521
+ }
522
+ }
523
+ return false;
524
+ }
525
+ // src/untracked.ts
526
+ /** 在回调执行期间暂停依赖收集,也支持 untracked.bound 绑定上下文 */
527
+ var untracked = createBoundary(() => pauseTracking(), () => resetTracking());
528
+ export { Tracker, action, autorun, batch, computed, contains, isObservable, isReactive, observable, observe, reaction, reactive, registerSkip, shallow, shallowRef, toJS, untracked };
529
+
530
+ //# sourceMappingURL=index.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"index.js","names":["reactive","vueReactive","vueShallowRef","vueComputed"],"sources":["../src/decorator.ts","../src/internals.ts","../src/observable.ts","../src/reactive.ts","../src/shallowRef.ts","../src/shallow.ts","../src/computed.ts","../src/observe.ts","../src/batch.ts","../src/autorun.ts","../src/tracker.ts","../src/action.ts","../src/externals.ts","../src/untracked.ts"],"sourcesContent":["type AccessorDecorator = (\n value: ClassAccessorDecoratorTarget<any, any>,\n context: ClassAccessorDecoratorContext\n) => ClassAccessorDecoratorResult<any, any>\n\n/** 懒加载哨兵:构造期暂存原始值,字段首次读写时才替换成真正的响应式盒子 */\ninterface LazySlot {\n raw: unknown\n}\n\n/**\n * accessor 装饰器通用工厂:字段值存进 createBox 返回的盒子,读写都经过盒子,\n * 因此重新赋值也能保持响应式(普通 field 装饰器只能改写初始值)。\n * normalize 用于写入前归一化(如把对象包成响应式代理),默认原样透传。\n *\n * 懒加载:构造期只创建轻量哨兵保存初始值,不调用 createBox;\n * 直到该字段第一次被读/写时才真正创建响应式盒子并回写私有槽,之后一直复用。\n *\n * 实现约束:\n * 1. 用 WeakSet 识别哨兵而非 symbol 品牌——盒子可能是 Vue Proxy,属性访问会触发\n * get trap 并污染依赖收集,WeakSet 按对象 identity 判定,零 trap 副作用;\n * 2. WeakSet 的 key 必须是槽位对象而不能是类实例:实例首次作为 WeakCollection key\n * 会被 V8 附加 identity hash 并触发 map transition,使实例隐藏类失稳、字段访问\n * 内联缓存多态化,实测全激活路径反而慢 4~18 倍;\n * 3. 槽位替换后哨兵失去引用即可被 GC,WeakSet 不造成泄漏。\n *\n * 注意:field 装饰器没有读写拦截点,无法懒加载,仍在构造期即时转换。\n */\nexport function accessorDecorator(\n createBox: (initialValue: any) => any,\n normalize: (value: any) => any = value => value\n): AccessorDecorator {\n // 每个被装饰字段独立一份哨兵集合,随类定义常驻\n const lazySlots = new WeakSet<object>()\n\n return (target, _context) => ({\n init(initialValue) {\n const slot: LazySlot = { raw: initialValue }\n lazySlots.add(slot)\n return slot\n },\n get(this: any) {\n const slot = target.get.call(this)\n if (lazySlots.has(slot)) {\n const box = createBox(normalize(slot.raw))\n target.set.call(this, box)\n return box.value\n }\n return slot.value\n },\n set(this: any, value: any) {\n const slot = target.get.call(this)\n if (lazySlots.has(slot)) {\n // 初始值从未对外暴露,直接以新值建盒,等价于覆盖初始值\n target.set.call(this, createBox(normalize(value)))\n return\n }\n slot.value = normalize(value)\n },\n })\n}\n","import { isRef, toRaw, unref } from '@vue/reactivity'\n\nimport type { IChange, Observer } from './types'\n\nexport interface Entry {\n fn: Observer\n deep: boolean\n}\n\nconst SKIP_CTORS = [Date, RegExp, Map, Set, WeakMap, WeakSet, Promise]\n\n/** 内层 Vue reactive proxy -> 观察者集合 */\nexport const handlerMap = new WeakMap<object, Set<Entry>>()\n/** 子 -> 所有父 */\nexport const parentMap = new WeakMap<object, Set<object>>()\n/** 子 + 父 -> 在父里的 key */\nexport const parentKeyMap = new WeakMap<object, Map<object, PropertyKey>>()\n/** 内层 proxy -> 外层 proxy */\nexport const proxyCache = new WeakMap<object, object>()\n/** 外层 proxy -> 内层 proxy */\nexport const reverseCache = new WeakMap<object, object>()\n\nexport type SkipMatcher = (value: object) => boolean\n\nconst skipMatchers = new Set<SkipMatcher>()\n\n/**\n * 注册“跳过包装”的判定,可注册多个,任一命中即跳过;返回销毁函数。\n * 命中的值不会生成外层 proxy,元素本身及其嵌套结构保持原始引用。\n */\nexport function registerSkip(matcher: SkipMatcher): () => void {\n skipMatchers.add(matcher)\n return () => {\n skipMatchers.delete(matcher)\n }\n}\n\n/** React 元素、Vue VNode 以及自定义跳过判定 */\nexport function shouldSkip(v: unknown): boolean {\n if (v === null || typeof v !== 'object') return false\n if ('$$typeof' in v && '_owner' in v) return true\n if ((v as any).__v_isVNode === true) return true\n for (const matcher of skipMatchers) {\n if (matcher(v)) return true\n }\n return false\n}\n\nexport function canProxy(v: unknown): v is object {\n if (v === null || typeof v !== 'object') return false\n if (isRef(v)) return false\n if ((v as any).__v_skip) return false\n if (shouldSkip(v)) return false\n for (const C of SKIP_CTORS) if (v instanceof C) return false\n return true\n}\n\nexport function addParent(childVueProxy: object, parentVueProxy: object, key: PropertyKey) {\n let parents = parentMap.get(childVueProxy)\n if (!parents) {\n parents = new Set()\n parentMap.set(childVueProxy, parents)\n }\n parents.add(parentVueProxy)\n\n let keys = parentKeyMap.get(childVueProxy)\n if (!keys) {\n keys = new Map()\n parentKeyMap.set(childVueProxy, keys)\n }\n keys.set(parentVueProxy, key)\n}\n\nexport function wrap(vueProxy: any, parentVueProxy?: any, parentKey?: PropertyKey, shallow = false): any {\n if (!canProxy(vueProxy)) return vueProxy\n\n let proxy = proxyCache.get(vueProxy)\n if (!proxy) {\n proxy = new Proxy(vueProxy, {\n get(target, key, receiver) {\n const raw = Reflect.get(target, key, receiver)\n // __v_raw 必须原样返回,否则 toRaw 会再次命中代理,导致 track / trigger 目标不一致\n if (key === '__v_raw') return raw\n const value = unref(raw)\n // ref 只解包,不做代理;嵌套对象按需懒代理,并登记父子关系\n if (value !== raw) return value\n // 元素需要保持原始引用,Vue 可能已把它的嵌套对象包成 reactive proxy\n if (shouldSkip(value)) return toRaw(value)\n if (!shallow && canProxy(value)) return wrap(value, target, key)\n return value\n },\n set(target, key, value) {\n const raw = toRaw(target) as any\n const had = Object.prototype.hasOwnProperty.call(raw, key)\n const oldValue = raw[key]\n\n const result = Reflect.set(target, key, value)\n\n if (result && !Object.is(oldValue, value)) {\n notifyDeep(target, {\n type: had ? 'set' : 'add',\n key,\n value,\n oldValue,\n target,\n path: [],\n })\n }\n return result\n },\n deleteProperty(target, key) {\n const raw = toRaw(target) as any\n const had = Object.prototype.hasOwnProperty.call(raw, key)\n const oldValue = raw[key]\n\n const result = Reflect.deleteProperty(target, key)\n\n if (had && result) {\n notifyDeep(target, {\n type: 'delete',\n key,\n value: undefined,\n oldValue,\n target,\n path: [],\n })\n }\n return result\n },\n })\n proxyCache.set(vueProxy, proxy)\n reverseCache.set(proxy, vueProxy)\n }\n\n if (parentVueProxy) addParent(vueProxy, parentVueProxy, parentKey!)\n return proxy\n}\n\n// 变更点自身通知所有观察者;向上沿父链传播时,只通知 deep=true 的观察者\nexport function notifyDeep(sourceVueProxy: object, change: IChange) {\n // 1) 直接变更的对象:所有观察者都通知,path 为 []\n const own = handlerMap.get(sourceVueProxy)\n if (own) own.forEach(e => e.fn({ ...change, path: [] }))\n\n // 2) BFS 向上传播\n const visited = new Set<object>([sourceVueProxy])\n const queue: Array<{ node: object; path: PropertyKey[] }> = []\n\n const seedParents = parentMap.get(sourceVueProxy)\n if (seedParents) {\n for (const p of seedParents) {\n const k = parentKeyMap.get(sourceVueProxy)?.get(p)\n if (k !== undefined) queue.push({ node: p, path: [k] })\n }\n }\n\n while (queue.length) {\n const { node, path } = queue.shift()!\n if (visited.has(node)) continue\n visited.add(node)\n\n const set = handlerMap.get(node)\n if (set) {\n set.forEach(e => {\n if (e.deep) e.fn({ ...change, path: [...path] })\n })\n }\n\n const parents = parentMap.get(node)\n if (parents) {\n for (const p of parents) {\n const k = parentKeyMap.get(node)?.get(p)\n if (k !== undefined) queue.push({ node: p, path: [k, ...path] })\n }\n }\n }\n}\n","import { isRef, reactive } from '@vue/reactivity'\n\nimport { accessorDecorator } from './decorator'\nimport { shouldSkip, wrap } from './internals'\n\nexport interface IObservable {\n (\n value: ClassAccessorDecoratorTarget<any, any>,\n context: ClassAccessorDecoratorContext\n ): ClassAccessorDecoratorResult<any, any>\n (value: undefined, context: ClassFieldDecoratorContext): (initialValue: any) => any\n <T>(source: T): T\n}\n\nconst REACTIVE_TAGS = new Set([\n '[object Object]',\n '[object Array]',\n '[object Map]',\n '[object Set]',\n '[object WeakMap]',\n '[object WeakSet]',\n])\n\nfunction isReactiveTarget(value: unknown): value is object {\n if (value === null || typeof value !== 'object') return false\n if (isRef(value)) return false\n if ((value as any).__v_skip) return false\n if (shouldSkip(value)) return false\n return REACTIVE_TAGS.has(Object.prototype.toString.call(value))\n}\n\nfunction toObservable<T>(source: T): T {\n if (!isReactiveTarget(source)) return source\n return wrap(reactive(source)) as T\n}\n\nfunction observableImpl(source: any, context?: any) {\n if (!context) return toObservable(source)\n if (context.kind === 'field') return (initialValue: any) => toObservable(initialValue)\n if (context.kind === 'accessor') return accessorDecorator(value => toObservable({ value }))(source, context)\n return source\n}\n\n/**\n * 创建可被 observe 的响应式对象(formvk 外层代理 + Vue 深响应式),\n * 同时支持 field / accessor 装饰器。\n * 这是唯一能被 observe 监听的入口;只需要 autorun 追踪时请改用 reactive/shallowRef/shallow。\n */\nexport const observable: IObservable = observableImpl as IObservable\n","import { reactive as vueReactive } from '@vue/reactivity'\n\nimport { accessorDecorator } from './decorator'\n\nexport interface IReactive {\n (\n value: ClassAccessorDecoratorTarget<any, any>,\n context: ClassAccessorDecoratorContext\n ): ClassAccessorDecoratorResult<any, any>\n (value: undefined, context: ClassFieldDecoratorContext): (initialValue: any) => any\n <T>(source: T): T\n}\n\n/** 纯 Vue 深响应式:只服务 autorun/effect,不进入 formvk 代理层,不可被 observe */\nfunction toReactive<T>(source: T): T {\n if (source === null || typeof source !== 'object') return source\n return vueReactive(source) as T\n}\n\nfunction reactiveImpl(value: any, context?: any) {\n if (!context) return toReactive(value)\n if (context.kind === 'field') return (initialValue: any) => toReactive(initialValue)\n if (context.kind === 'accessor') {\n return accessorDecorator(initialValue => toReactive({ value: initialValue }))(value, context)\n }\n return value\n}\n\n/**\n * 创建纯 Vue 响应式对象(深响应),同时支持 field / accessor 装饰器。\n * 与 observable 的区别:不包 formvk 外层代理,没有变更路径传播,不能被 observe 监听。\n */\nexport const reactive: IReactive = reactiveImpl as IReactive\n","import { shallowRef as vueShallowRef } from '@vue/reactivity'\nimport type { ShallowRef } from '@vue/reactivity'\n\nimport { accessorDecorator } from './decorator'\n\nexport interface IShallowRef {\n (\n value: ClassAccessorDecoratorTarget<any, any>,\n context: ClassAccessorDecoratorContext\n ): ClassAccessorDecoratorResult<any, any>\n (value: undefined, context: ClassFieldDecoratorContext): (initialValue: any) => any\n <T>(value: T): ShallowRef<T>\n}\n\nfunction shallowRefImpl(value: any, context?: any) {\n if (!context) return vueShallowRef(value)\n if (context.kind === 'accessor') {\n return accessorDecorator(initialValue => vueShallowRef(initialValue))(value, context)\n }\n // 普通字段无法拦截读写,保持原值;shallowRef 请配合 accessor 使用\n return value\n}\n\n/**\n * 浅响应式盒子(Vue shallowRef):只有整体替换 .value 才触发通知,\n * 盒子内对象的深层变更不具响应性。不可被 observe,变更请用 autorun 监听。\n */\nexport const shallowRef: IShallowRef = shallowRefImpl as IShallowRef\n","import { shallowReactive } from '@vue/reactivity'\n\nimport { accessorDecorator } from './decorator'\n\nexport interface IShallow {\n (\n value: ClassAccessorDecoratorTarget<any, any>,\n context: ClassAccessorDecoratorContext\n ): ClassAccessorDecoratorResult<any, any>\n (value: undefined, context: ClassFieldDecoratorContext): (initialValue: any) => any\n <T>(source: T): T\n}\n\n/** 纯 Vue 浅响应式:仅顶层属性变化触发通知,嵌套值保持原始引用 */\nfunction toShallow<T>(source: T): T {\n if (source === null || typeof source !== 'object') return source\n return shallowReactive(source) as T\n}\n\nfunction shallowImpl(value: any, context?: any) {\n if (!context) return toShallow(value)\n if (context.kind === 'field') return (initialValue: any) => toShallow(initialValue)\n if (context.kind === 'accessor') {\n return accessorDecorator(initialValue => toShallow({ value: initialValue }))(value, context)\n }\n return value\n}\n\n/**\n * 创建纯 Vue 浅响应式对象,同时支持 field / accessor 装饰器。\n * 不包 formvk 外层代理,不可被 observe,变更请用 autorun 监听。\n */\nexport const shallow: IShallow = shallowImpl as IShallow\n","import { computed as vueComputed } from '@vue/reactivity'\nimport type { ComputedRef } from '@vue/reactivity'\n\n/** computed 函数形态的只读返回值 */\nexport interface ComputedValue<T> {\n readonly value: T\n}\n\n/** computed 函数形态的可写返回值 */\nexport interface WritableComputedValue<T> {\n value: T\n}\n\nexport interface IComputed {\n <T>(getter: (this: any) => T, context: ClassGetterDecoratorContext): (this: any) => T\n <T>(getter: () => T): ComputedValue<T>\n <T>(options: { get: () => T }): ComputedValue<T>\n <T>(options: { get: () => T; set: (value: T) => void }): WritableComputedValue<T>\n}\n\nfunction computedImpl(compute: any, context?: any) {\n if (!context) return vueComputed(compute)\n if (context.kind !== 'getter') {\n throw new Error('[formvk] computed 只支持 getter 装饰器')\n }\n // getter 装饰器在原型上只安装一次,按实例缓存 computed\n const cache = new WeakMap<object, ComputedRef<any>>()\n return function (this: any) {\n let result = cache.get(this)\n if (!result) {\n result = vueComputed(() => compute.call(this))\n cache.set(this, result)\n }\n return result.value\n }\n}\n\n/**\n * 创建 Vue 计算属性,或作为 getter 装饰器按实例缓存计算结果。\n * 纯 Vue 响应式,不可被 observe。\n */\nexport const computed: IComputed = computedImpl as IComputed\n","import type { Entry } from './internals'\nimport { handlerMap, reverseCache } from './internals'\nimport type { Observer } from './types'\n\n/** 监听对象所有写操作,返回 dispose;仅支持 observable() 创建的对象 */\nexport function observe<T extends object>(target: T, observer: Observer, deep = true): () => void {\n const vueProxy = reverseCache.get(target as any)\n if (!vueProxy) {\n throw new Error(\n '[formvk] observe 仅支持 observable() 创建的对象;reactive/shallowRef/shallow/computed 的变更请用 autorun 监听'\n )\n }\n let set = handlerMap.get(vueProxy)\n if (!set) {\n set = new Set()\n handlerMap.set(vueProxy, set)\n }\n\n const entry: Entry = { fn: observer, deep }\n set.add(entry)\n\n return () => {\n set!.delete(entry)\n }\n}\n","import type { AnyFunction, BindFunction, Boundary, IBatch } from './types'\n\ntype Runner = () => void\n\nfunction isDecoratorContext(context: any): context is { kind: string } {\n return !!context && typeof context === 'object' && typeof context.kind === 'string'\n}\n\nlet batchCount = 0\nlet batchScope = false\n\nconst pendingReactions = new Set<Runner>()\nconst pendingScopeReactions = new Set<Runner>()\nconst batchEndpoints = new Set<() => void>()\n\nfunction runAll(runners: Set<Runner>) {\n if (runners.size === 0) return\n const queue = Array.from(runners)\n runners.clear()\n for (const run of queue) {\n run()\n }\n}\n\nexport function batchStart() {\n batchCount++\n}\n\nexport function batchEnd() {\n batchCount--\n if (batchCount === 0) {\n runAll(pendingReactions)\n const endpoints = Array.from(batchEndpoints)\n batchEndpoints.clear()\n for (const endpoint of endpoints) {\n endpoint()\n }\n }\n}\n\nexport function batchScopeStart() {\n batchScope = true\n // 把批次中尚未刷新的 reaction 转移到 scope,使 scope 结束时能读到最新值\n pendingReactions.forEach(runner => pendingScopeReactions.add(runner))\n pendingReactions.clear()\n}\n\nexport function batchScopeEnd() {\n batchScope = false\n runAll(pendingScopeReactions)\n}\n\n/** reaction 的调度入口:非批量状态立即执行,否则延迟到批次结束 */\nexport function scheduleReaction(runner: Runner) {\n if (batchScope) {\n pendingScopeReactions.add(runner)\n } else if (batchCount > 0) {\n pendingReactions.add(runner)\n } else {\n runner()\n }\n}\n\n/** 创建在 start / end 之间执行回调的边界函数,可同时作为类成员装饰器 */\nexport function createBoundary(start: () => void, end: () => void): Boundary {\n function invoke<T>(callback?: () => T): T {\n let result = undefined as T\n try {\n start()\n if (typeof callback === 'function') {\n result = callback()\n }\n } finally {\n end()\n }\n return result as T\n }\n\n function wrap(callback: AnyFunction) {\n return function (this: any, ...args: any[]) {\n return invoke(() => callback.apply(this, args))\n }\n }\n\n function decorate(callback: any, context: any) {\n if (context.kind === 'field') {\n return (initialValue: any) => (typeof initialValue === 'function' ? wrap(initialValue) : initialValue)\n }\n if (typeof callback !== 'function') return callback\n return wrap(callback)\n }\n\n const boundary = ((callback?: any, context?: any) => {\n if (isDecoratorContext(context)) {\n return decorate(callback, context)\n }\n return invoke(callback)\n }) as Boundary\n\n const bound: BindFunction = (callback, context) =>\n ((...args: any[]) => invoke(() => callback?.apply(context, args))) as any\n\n boundary.bound = bound\n return boundary\n}\n\nconst scopeBoundary = createBoundary(batchScopeStart, batchScopeEnd)\n\n/** 批量执行:合并批次内的响应式写入,批次结束时统一刷新 reaction */\nexport const batch = Object.assign(createBoundary(batchStart, batchEnd), {\n scope: scopeBoundary,\n endpoint: (callback?: () => void) => {\n if (typeof callback !== 'function') return\n if (batchCount === 0) {\n callback()\n } else {\n batchEndpoints.add(callback)\n }\n },\n}) as IBatch\n","import { effect, pauseTracking, resetTracking, stop } from '@vue/reactivity'\n\nimport { scheduleReaction } from './batch'\nimport type { Dispose, IReactionOptions } from './types'\n\n/**\n * 自动运行:立即执行 tracker,并追踪其中读取的响应式数据,\n * 任意依赖变化都会整体重跑 tracker。\n */\nexport function autorun(tracker: () => void): Dispose {\n const runner = effect(tracker, {\n scheduler: () => scheduleReaction(runner),\n })\n return () => stop(runner)\n}\n\n/**\n * 自定义运行:tracker 只负责求值并收集依赖,\n * 依赖变化后重新求值,值发生变更才调用 subscriber。\n */\nexport function reaction<T>(\n tracker: () => T,\n subscriber?: (value: T, oldValue: T) => void,\n options?: IReactionOptions<T>\n): Dispose {\n const equals = options?.equals ?? ((oldValue: T, newValue: T) => oldValue === newValue)\n let oldValue = undefined as T\n let firstRun = true\n const runner = effect(\n () => {\n const newValue = tracker()\n if (firstRun) {\n firstRun = false\n oldValue = newValue\n return\n }\n if (equals(oldValue, newValue)) return\n const prevValue = oldValue\n oldValue = newValue\n if (!subscriber) return\n // subscriber 中的读取不属于 tracker 依赖\n pauseTracking()\n try {\n subscriber(newValue, prevValue)\n } finally {\n resetTracking()\n }\n },\n {\n scheduler: () => scheduleReaction(runner),\n }\n )\n if (options?.fireImmediately) {\n subscriber?.(oldValue, oldValue)\n }\n return () => stop(runner)\n}\n","import { effect, stop } from '@vue/reactivity'\nimport type { ReactiveEffectRunner } from '@vue/reactivity'\n\nimport type { Dispose } from './types'\n\n/**\n * 手动追踪器:track 时立即执行 view 并收集其中读取的响应式依赖,\n * 依赖变化时只触发 scheduler 通知外部,不会自动重跑 view,\n * 由外部(如 React 的 forceUpdate)决定何时再次调用 track。\n * 主要供 UI 框架在渲染期手动接管追踪时机。\n */\nexport class Tracker {\n private runner: ReactiveEffectRunner<void>\n private view: () => unknown = () => undefined\n private result: unknown\n\n constructor(scheduler?: () => void) {\n // 构造时先空跑一次,真正的依赖收集发生在外部手动调用 track 时\n this.runner = effect(\n () => {\n this.result = this.view()\n },\n {\n // 无 scheduler 时也不能让 effect 自动重跑,保持「只通知、不执行」语义\n scheduler: scheduler ?? (() => {}),\n }\n )\n }\n\n /** 执行 view 并重新收集依赖,返回本次执行结果;可重复调用,依赖以最近一次为准 */\n track<T>(view: () => T): T {\n this.view = view\n this.runner()\n return this.result as T\n }\n\n /** 停止追踪并释放全部响应式依赖 */\n dispose: Dispose = () => stop(this.runner)\n}\n","import { pauseTracking, resetTracking } from '@vue/reactivity'\n\nimport { batchEnd, batchScopeEnd, batchScopeStart, batchStart, createBoundary } from './batch'\nimport type { IAction } from './types'\n\n/** action = batch + untrack:合并通知,同时不收集执行期间的响应式读取 */\nexport const action = Object.assign(\n createBoundary(\n () => {\n batchStart()\n pauseTracking()\n },\n () => {\n resetTracking()\n batchEnd()\n }\n ),\n {\n scope: createBoundary(\n () => {\n batchScopeStart()\n pauseTracking()\n },\n () => {\n resetTracking()\n batchScopeEnd()\n }\n ),\n }\n) as IAction\n","import { isReactive, toRaw } from '@vue/reactivity'\n\nimport { parentMap, reverseCache } from './internals'\n\n/** 判断值是否是 Vue 响应式代理(reactive / shallowReactive 根对象) */\nexport { isReactive }\n\n/** 外层 proxy 统一还原为内层 Vue proxy,便于匹配父子关系;入参已由 contains 保证为非空对象 */\nfunction normalize(value: object): object {\n return reverseCache.get(value) ?? value\n}\n\n/** 判断值是否是 observable(wrap 出的 formvk 代理;纯 Vue reactive 不在此列) */\nexport function isObservable(value: any): boolean {\n if (value === null || typeof value !== 'object') return false\n return reverseCache.has(value)\n}\n\n/** 把可观察/响应式对象深拷贝为普通对象,其余值原样返回 */\nexport function toJS<T>(values: T): T {\n const visited = new WeakSet<object>()\n\n function convert(value: any): any {\n if (value === null || typeof value !== 'object') return value\n if (!isObservable(value) && !isReactive(value)) return value\n if (visited.has(value)) return toRaw(value)\n visited.add(value)\n if (Array.isArray(value)) {\n const result = value.map((item: any) => convert(item))\n visited.delete(value)\n return result\n }\n const result: Record<string, any> = {}\n for (const key in value) {\n result[key] = convert(value[key])\n }\n visited.delete(value)\n return result\n }\n\n return convert(values)\n}\n\n/** 判断 property 是否就是 target 自身或其后代节点 */\nexport function contains(target: any, property: any): boolean {\n if (target === property) return true\n if (target === null || typeof target !== 'object') return false\n if (property === null || typeof property !== 'object') return false\n\n const targetNode = normalize(target)\n const propertyNode = normalize(property)\n if (targetNode === propertyNode) return true\n\n const visited = new Set<object>([propertyNode])\n const queue: object[] = [propertyNode]\n while (queue.length) {\n const node = queue.shift()!\n const parents = parentMap.get(node)\n if (!parents) continue\n for (const parent of parents) {\n if (parent === targetNode) return true\n if (visited.has(parent)) continue\n visited.add(parent)\n queue.push(parent)\n }\n }\n return false\n}\n","import { pauseTracking, resetTracking } from '@vue/reactivity'\n\nimport { createBoundary } from './batch'\nimport type { Boundary } from './types'\n\n/** 在回调执行期间暂停依赖收集,也支持 untracked.bound 绑定上下文 */\nexport const untracked: Boundary = createBoundary(\n () => pauseTracking(),\n () => resetTracking()\n)\n"],"mappings":"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"}
package/package.json CHANGED
@@ -1,6 +1,28 @@
1
1
  {
2
2
  "name": "@formvk/reactive",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
3
+ "version": "1.0.0",
4
+ "description": "Formvk Shared",
5
+ "keywords": [
6
+ "form",
7
+ "formvk",
8
+ "formvk-shared",
9
+ "shared"
10
+ ],
11
+ "license": "MIT",
12
+ "author": "yiyunwan",
13
+ "files": [
14
+ "dist",
15
+ "CHANGELOG.md"
16
+ ],
17
+ "type": "module",
18
+ "main": "dist/index.js",
19
+ "module": "dist/index.js",
20
+ "types": "dist/index.d.ts",
21
+ "dependencies": {
22
+ "@vue/reactivity": "^3.6.0-rc.15"
23
+ },
24
+ "scripts": {
25
+ "build": "tsc --noEmit && vite build",
26
+ "test": "vitest"
27
+ }
6
28
  }