Signals 的标准化提案，来了！

const counter = new Signal.State(0);

// 读取Signal值
console.log(counter.get()); // 输出：0

// 改变Signal值
counter.set(1);
console.log(counter.get()); // 输出：1

// 创建一个基于 counter Signal 的计算型 Signal
const isEven = new Signal.Computed(() => (counter.get() & 1) === 0);

// 更新 counter Signal，并同时更新依赖的计算型 Signals
counter.set(17);
console.log(isEven.get()); // 输出：false

const parity = new Signal.Computed(() => isEven.get() ? "even" : "odd");

counter.set(17);
console.log(parity.get()); // odd

effect(() => element.innerText = parity.get());

interface Signal<T> {
  // 获取信号的值
  get(): T;
}

namespace Signal {
    // 一个可读写的信号
    class State<T> implements Signal<T> {
        // 创建一个初始值为t的状态信号
        constructor(t: T, options?: SignalOptions<T>);

        // 设置状态信号的值为t
        set(t: T): void;
    }

    // 一个基于其他信号的公式信号
    class Computed<T> implements Signal<T> {
        // 创建一个信号，它的值由回调函数的返回值决定。
        // 回调函数中的this指向这个公式信号本身。
        constructor(cb: (this: Computed<T>) => T, options?: SignalOptions<T>);
    }

    // 这个命名空间包括一些“高级”功能，通常情况下最好是留给框架的作者而不是应用程序开发者使用。
    // 类似于`crypto.subtle`
    namespace subtle {
        // 运行一个回调函数，并在该函数中停用所有的跟踪
        function untrack<T>(cb: () => T): T;

        // 如果存在，获取当前正在跟踪任何信号读取的公式信号
        function currentComputed(): Computed | null;

        // 返回一个有序的信号列表，这些信号是公式信号在上次计算中引用的所有信号。
        // 对于Watcher对象，列出它正在监视的信号集。
        function introspectSources(s: Computed | Watcher): (State | Computed)[];

        // 返回包含此信号的Watcher对象，加上读取此信号的所有公式信号（如果这个公式信号正在（递归）被监视的话）。
        function introspectSinks(s: State | Computed): (Computed | Watcher)[];

        // 如果此信号是“活动”状态，即它被一个Watcher对象监视，或它被一个正在（递归）活动监视的公式信号读取。
        function hasSinks(s: State | Computed): boolean;

        // 如果此信号是“响应式”的，即它依赖于其他某些信号。若一个公式信号没有源信号（即hasSources为false），它总是返回相同的常量。
        function hasSources(s: Computed | Watcher): boolean;

        class Watcher {
            // 当Watcher的一个（递归的）源信号被写入时，调用这个回调函数，
            // 如果自上次`watch`调用以来还没有被调用的话。
            // 在通知期间，不得读取或写入任何信号。
            constructor(notify: (this: Watcher) => void);

            // 添加这些信号到Watcher的集合中，设置Watcher在其任何一个信号集中的信号（或其依赖项）变化时，
            // 运行它的通知回调函数。也可以不带参数调用，仅重置“已通知”状态，这样可以再次触发通知回调函数。
            watch(...s: Signal[]): void;

            // 从观察集中移除这些信号（例如，对于已经处理过的effect）。
            unwatch(...s: Signal[]): void;

            // 返回Watcher集合中仍然是“脏”的源信号集，或者是有一个“脏”或等待中且尚未重新评估的源信号的公式信号。
            getPending(): Signal[];
        }

        // 用于观察启动监视和停止监视的钩子
        var watched: Symbol;
        var unwatched: Symbol;
    }

    interface Options<T> {
        // 自定义比较函数，用于比较旧值和新值是否相同。默认值：Object.is。
        // 信号对象本身作为this值传入，以供上下文使用。
        equals?: (this: Signal<T>, t: T, t2: T) => boolean;

        // 当isWatched变为true时（之前为false）的回调函数
        [Signal.subtle.watched]?: (this: Signal<T>) => void;

        // 每当isWatched变为false时（之前为true）的回调函数
        [Signal.subtle.unwatched]?: (this: Signal<T>) => void;
    }
}

export class Counter {
  #value = new Signal.State(0);

  get value() {
    return this.#value.get();
  }

  increment() {
    this.#value.set(this.#value.get() + 1);
  }

  decrement() {
    if (this.#value.get() > 0) {
      this.#value.set(this.#value.get() - 1);
    }
  }
}

const c = new Counter();
c.increment();
console.log(c.value);

export function signal(target) {
  const { get } = target;

  return {
    get() {
      return get.call(this).get();
    },

    set(value) {
      get.call(this).set(value);
    },

    init(value) {
      return new Signal.State(value);
    },
  };
}

export class Counter {
  @signal accessor #value = 0;

  get value() {
    return this.#value;
  }

  increment() {
    this.#value++;
  }

  decrement() {
    if (this.#value > 0) {
      this.#value--;
    }
  }
}

let needsEnqueue = true;

// 创建一个新的 Watcher 实例
const w = new Signal.subtle.Watcher(() => {
  if (needsEnqueue) {
    needsEnqueue = false;
    // 将 processPending 函数添加到微任务队列中
    queueMicrotask(processPending);
  }
});

// processPending 函数的定义
function processPending() {
  needsEnqueue = true;
    
  // 遍历 Watcher 的 Pending 队列中的每一个信号
  for (const s of w.getPending()) {
    // 获取每一个信号的值
    s.get();
  }

  // 开始监听这个 Watcher
  w.watch();
}

// effect 函数的定义
export function effect(callback) {
  let cleanup;
  
  // 创建一个新的 Computed 实例
  const computed = new Signal.Computed(() => {
    // 如果 cleanup 是一个函数，执行这个函数
    typeof cleanup === "function" && cleanup();
    // 将 callback 的运行结果赋值给 cleanup
    cleanup = callback();
  });
  
  // 开始监听这个 Computed 实例
  w.watch(computed);
  // 获取 Computed 实例的值
  computed.get();
  
  return () => {
    // 停止监听这个 Computed 实例
    w.unwatch(computed);
    // 如果 cleanup 是一个函数，执行这个函数
    typeof cleanup === "function" && cleanup();
  };
}

new Proxy(0, { ... }) // ❌ TypeError: Cannot create proxy with a non-object as target or handler

new Signal.State(0); // ✅