@warp-ts/reactivity 0.0.0-stage → 0.1.2

package/dist/types/error.d.ts

@@ -0,0 +1,7 @@
+export declare class WarpError extends Error {
+    code: string;
+    hint?: string | undefined;
+    constructor(code: string, message: string, hint?: string);
+}
+export declare function err(code: string, name?: string): WarpError;
+export declare function warn(code: string, name?: string): void;

package/dist/types/error.js

@@ -0,0 +1,28 @@
+// WARP-R1xx 诊断（设计 01-R §9）
+export class WarpError extends Error {
+    constructor(code, message, hint) {
+        super(`[${code}] ${message}`);
+        this.name = 'WarpError';
+        this.code = code;
+        this.hint = hint;
+    }
+}
+const MSG = __DEV__ ? {
+    'WARP-R101': n => `effect "${n}" 创建于无 owner 上下文，将永不释放；请放入组件 / createRoot 内`,
+    'WARP-R102': n => `检测到依赖环：${n}`,
+    'WARP-R103': n => `不能写入 computed "${n}"`,
+    'WARP-R104': n => `computed "${n}" 内写入了 signal，computed 必须是纯函数`,
+    'WARP-R105': n => `computed "${n}" 内创建了 effect / createRoot，computed 必须是纯函数（重算不会释放它们）`,
+} : {};
+export function err(code, name) {
+    if (__DEV__) {
+        const f = MSG[code];
+        if (f)
+            return new WarpError(code, f(name || '(anonymous)'));
+    }
+    return new WarpError(code, code);
+}
+export function warn(code, name) {
+    if (__DEV__)
+        console.warn(err(code, name).message);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export { signal, computed, effect, renderEffect, createSelector, batch, untrack, flushSync, onCleanup, createRoot, getOwner, runWithOwner, ownerView, __DEV_graph, __DEV_onFlush } from './core';
+export type { Signal, Owner, SignalOptions, GraphSnapshot, OwnerDevInfo } from './core';
+export { reactive, shallowReactive, isReactive, toRaw } from './reactive';
+export { WarpError } from './error';
+/** @internal 供 core / runtime-dom 使用 */
+export { _setOwnerError, _setOwnerDev, _ownerContext, _notify, _track, _mkSignalNode, _hasListener, _lightSignal, _write, _rootRun, _disposeOwner, _childrenOf } from './core';
+/** @internal REQ-LFE-002 ADR-205：服务端模式（@warp-ts/server 启用） */
+export { enableServerMode } from './core';
+export type { SignalNode } from './types';

package/dist/types/index.js

@@ -0,0 +1,8 @@
+// @warp-ts/reactivity · REQ-LFE-001-R · 公开 API（设计 00 §4.1）
+export { signal, computed, effect, renderEffect, createSelector, batch, untrack, flushSync, onCleanup, createRoot, getOwner, runWithOwner, ownerView, __DEV_graph, __DEV_onFlush } from './core';
+export { reactive, shallowReactive, isReactive, toRaw } from './reactive';
+export { WarpError } from './error';
+/** @internal 供 core / runtime-dom 使用 */
+export { _setOwnerError, _setOwnerDev, _ownerContext, _notify, _track, _mkSignalNode, _hasListener, _lightSignal, _write, _rootRun, _disposeOwner, _childrenOf } from './core';
+/** @internal REQ-LFE-002 ADR-205：服务端模式（@warp-ts/server 启用） */
+export { enableServerMode } from './core';

package/dist/types/reactive.d.ts

@@ -0,0 +1,4 @@
+export declare function toRaw<T>(o: T): T;
+export declare function isReactive(o: unknown): boolean;
+export declare function reactive<T extends object>(o: T): T;
+export declare function shallowReactive<T extends object>(o: T): T;

package/dist/types/reactive.js

@@ -0,0 +1,208 @@
+// @warp-ts/reactivity · REQ-LFE-001-R-05 · Proxy 深响应（设计 01-R §6）
+import { _hasListener, _mkSignalNode, _notify, _track, batch, untrack } from './core';
+const RAW = Symbol('warp.raw');
+const ITERATE = Symbol('warp.iterate');
+const proxyMap = new WeakMap();
+const shallowMap = new WeakMap();
+const depMap = new WeakMap();
+function track(raw, key) {
+    if (!_hasListener())
+        return;
+    let m = depMap.get(raw);
+    if (!m)
+        depMap.set(raw, m = new Map());
+    let n = m.get(key);
+    if (!n)
+        m.set(key, n = _mkSignalNode());
+    _track(n);
+}
+function trigger(raw, key, alsoIterate = false, keys) {
+    const m = depMap.get(raw);
+    if (!m)
+        return;
+    batch(() => {
+        const fire = (n) => { if (n)
+            _notify(n); };
+        fire(m.get(key));
+        if (keys)
+            for (const k of keys)
+                fire(m.get(k));
+        if (alsoIterate) {
+            fire(m.get(ITERATE));
+            if (Array.isArray(raw))
+                fire(m.get('length'));
+        }
+    });
+}
+export function toRaw(o) { return (o && o[RAW]) || o; }
+export function isReactive(o) { return !!(o && o[RAW]); }
+function canProxy(o) {
+    if (!o || typeof o !== 'object' || Object.isFrozen(o) || !Object.isExtensible(o))
+        return false;
+    const t = Object.prototype.toString.call(o);
+    return /^\[object (Object|Array|Map|Set|WeakMap|WeakSet)\]$/.test(t);
+}
+function wrap(v, shallow) { return shallow || !canProxy(v) ? v : createProxy(v, false); }
+// ---- 数组 instrumentation ----
+const arrayInst = {};
+for (const m of ['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse']) {
+    arrayInst[m] = function (...args) {
+        const raw = toRaw(this);
+        const before = raw.length;
+        args = args.map(toRaw); // RDC-15（006 L-12）：写入参数与 set 陷阱同口径落 raw（`toRaw` 对非对象原样返回）
+        const r = batch(() => untrack(() => Array.prototype[m].apply(raw, args)));
+        if (m === 'sort' || m === 'reverse')
+            trigger(raw, ITERATE, true, Array.from(raw.keys(), String)); // 键统一为字符串（RDC-12）
+        else {
+            const after = raw.length;
+            const lo = m === 'push' ? before : m === 'pop' ? after : 0;
+            const hi = Math.max(before, after);
+            const ks = [];
+            for (let i = lo; i < hi; i++)
+                ks.push(String(i));
+            trigger(raw, 'length', true, ks);
+        }
+        return r;
+    };
+}
+for (const m of ['includes', 'indexOf', 'lastIndexOf']) {
+    arrayInst[m] = function (...args) {
+        const raw = toRaw(this);
+        track(raw, 'length');
+        for (let i = 0; i < raw.length; i++)
+            track(raw, String(i));
+        const fn = Array.prototype[m];
+        const r = fn.apply(raw, args);
+        if ((r === -1 || r === false) && args.length)
+            return fn.apply(raw, [toRaw(args[0]), ...args.slice(1)]);
+        return r;
+    };
+}
+function baseHandlers(shallow) {
+    return {
+        get(raw, key, receiver) {
+            if (key === RAW)
+                return raw;
+            if (Array.isArray(raw) && typeof key === 'string' && Object.prototype.hasOwnProperty.call(arrayInst, key))
+                return arrayInst[key];
+            track(raw, key);
+            return wrap(Reflect.get(raw, key, receiver), shallow);
+        },
+        set(raw, key, v, receiver) {
+            v = toRaw(v);
+            const had = Object.prototype.hasOwnProperty.call(raw, key);
+            const old = raw[key];
+            const isArr = Array.isArray(raw);
+            const oldLen = isArr ? raw.length : 0;
+            const ok = Reflect.set(raw, key, v, receiver);
+            if (!had)
+                trigger(raw, key, true);
+            else if (!Object.is(old, v)) {
+                if (isArr && key === 'length') {
+                    const ks = [];
+                    for (let i = v; i < oldLen; i++)
+                        ks.push(String(i));
+                    trigger(raw, 'length', true, ks);
+                }
+                else
+                    trigger(raw, key);
+            }
+            if (isArr && key !== 'length' && raw.length !== oldLen)
+                trigger(raw, 'length', true);
+            return ok;
+        },
+        deleteProperty(raw, key) {
+            const had = Object.prototype.hasOwnProperty.call(raw, key);
+            const ok = Reflect.deleteProperty(raw, key);
+            if (had && ok)
+                trigger(raw, key, true);
+            return ok;
+        },
+        has(raw, key) { if (key !== RAW)
+            track(raw, key); return Reflect.has(raw, key); },
+        ownKeys(raw) { track(raw, ITERATE); if (Array.isArray(raw))
+            track(raw, 'length'); return Reflect.ownKeys(raw); },
+    };
+}
+function collHandlers(shallow, weak) {
+    const inst = {
+        get(k) { const raw = toRaw(this); k = toRaw(k); track(raw, k); return wrap(raw.get(k), shallow); },
+        has(k) { const raw = toRaw(this); k = toRaw(k); track(raw, k); return raw.has(k); },
+        set(k, v) {
+            const raw = toRaw(this);
+            k = toRaw(k);
+            v = toRaw(v);
+            const had = raw.has(k);
+            const old = raw.get(k);
+            raw.set(k, v);
+            if (!had)
+                trigger(raw, k, true);
+            else if (!Object.is(old, v))
+                trigger(raw, k);
+            return this;
+        },
+        add(v) { const raw = toRaw(this); v = toRaw(v); if (!raw.has(v)) {
+            raw.add(v);
+            trigger(raw, v, true);
+        } return this; },
+        delete(k) { const raw = toRaw(this); k = toRaw(k); const had = raw.has(k); const r = raw.delete(k); if (had)
+            trigger(raw, k, true); return r; },
+        clear() { const raw = toRaw(this); const ks = [...raw.keys()]; const had = ks.length > 0; raw.clear(); if (had)
+            trigger(raw, ITERATE, true, ks); },
+        forEach(cb, thisArg) {
+            const raw = toRaw(this);
+            track(raw, ITERATE);
+            raw.forEach((v, k) => cb.call(thisArg, wrap(v, shallow), wrap(k, shallow), this));
+        },
+    };
+    const iter = (name) => function () {
+        const raw = toRaw(this);
+        track(raw, ITERATE);
+        const isEntries = name === 'entries' || (name === Symbol.iterator && raw instanceof Map);
+        const it = raw[name].call(raw);
+        return {
+            next() { const r = it.next(); if (r.done)
+                return r; const v = r.value; return { done: false, value: isEntries ? [wrap(v[0], shallow), wrap(v[1], shallow)] : wrap(v, shallow) }; },
+            [Symbol.iterator]() { return this; },
+        };
+    };
+    // RDC-14 / U-4（006 L-15）：Weak* 只挂 get / has / set / delete / add ——
+    // 其余成员不装配，取值时落到 `Reflect.get(raw, …)`，与原生 WeakMap / WeakSet 一样是 undefined
+    if (weak) {
+        delete inst.clear;
+        delete inst.forEach;
+    }
+    else {
+        inst.keys = iter('keys');
+        inst.values = iter('values');
+        inst.entries = iter('entries');
+        inst[Symbol.iterator] = iter(Symbol.iterator);
+    }
+    return {
+        get(raw, key, receiver) {
+            if (key === RAW)
+                return raw;
+            if (key === 'size' && !weak) {
+                track(raw, ITERATE);
+                return Reflect.get(raw, 'size', raw);
+            }
+            if (Object.prototype.hasOwnProperty.call(inst, key))
+                return inst[key];
+            return Reflect.get(raw, key, receiver);
+        },
+    };
+}
+function createProxy(o, shallow) {
+    const raw = toRaw(o);
+    const cache = shallow ? shallowMap : proxyMap;
+    const hit = cache.get(raw);
+    if (hit)
+        return hit;
+    const weak = raw instanceof WeakMap || raw instanceof WeakSet;
+    const isColl = weak || raw instanceof Map || raw instanceof Set;
+    const p = new Proxy(raw, isColl ? collHandlers(shallow, weak) : baseHandlers(shallow));
+    cache.set(raw, p);
+    return p;
+}
+export function reactive(o) { return (canProxy(o) ? createProxy(o, false) : o); }
+export function shallowReactive(o) { return (canProxy(o) ? createProxy(o, true) : o); }

package/dist/types/types.d.ts

@@ -0,0 +1,40 @@
+export declare const CLEAN = 0, CHECK = 1, DIRTY = 2;
+export type State = 0 | 1 | 2;
+export interface SignalNode<T = unknown> {
+    _v: T;
+    _eq: (a: T, b: T) => boolean;
+    _subs: Computation<any> | Computation<any>[] | null;
+    _subSlots: number | number[] | null;
+    _name?: string | undefined;
+    _id?: number;
+}
+/** computed 与 effect 共用；effect 同时是 Owner（承载其内部创建的子节点） */
+export interface Computation<T = unknown> extends SignalNode<T>, OwnerNode {
+    _fn: ((onCleanup: (f: () => void) => void) => T) | null;
+    _sources: SignalNode<any> | SignalNode<any>[] | null;
+    _sourceSlots: number | number[] | null;
+    _state: State;
+    _pure: boolean;
+    _running: boolean;
+    _updatedAt: number;
+    _seq: number;
+    _seen?: number;
+}
+export interface OwnerNode {
+    _parent: OwnerNode | null;
+    _children: OwnerNode | Computation<any> | (OwnerNode | Computation<any>)[] | null;
+    _cleanups: (() => void)[] | null;
+    _context: Map<symbol, unknown> | null;
+    _disposed: boolean;
+    _dead?: number;
+    _err?: ((e: unknown) => boolean | void) | null;
+    _name?: string | undefined;
+    _id?: number;
+    _hmrId?: string | undefined;
+    _devC?: Computation<any>[];
+    _node?: unknown;
+}
+export declare function isComputation(n: SignalNode<any> | OwnerNode): n is Computation<any>;
+declare global {
+    var __DEV__: boolean;
+}

package/dist/types/types.js

@@ -0,0 +1,5 @@
+// @warp-ts/reactivity · REQ-LFE-001-R · 内部数据结构（设计 01-R §1）
+export const CLEAN = 0, CHECK = 1, DIRTY = 2;
+export function isComputation(n) {
+    return n._pure !== undefined;
+}

package/package.json

@@ -1,6 +1,22 @@
 {
   "name": "@warp-ts/reactivity",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.2",
+  "description": "Signal / Computed / Effect / batch / owner 树 / reactive",
+  "type": "module",
+  "sideEffects": false,
+  "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "development": "./dist/index.dev.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {}
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-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.