一些初步想法：

• 根据我的理解，a.watch3('b', {c: {d: true}}, cb)的第一个参数是一个必须与其中一个属性匹配的名称，Matcher对象应该“Map”到该属性的值。但是我建议将Matcher对象与 current 对象（this）Map，并将b放入Matcher中，这样你就可以省略第一个参数：

a.watch3({b: {c: {d: true}}}, cb);

• 我会对所有签名使用一个watch方法，其中回调总是第一个参数，Matcher对象是可选的第二个参数。在我看来，名称论证没有必要（上一点）。
• 我假设一个回调只能被调用一次。这是一个在以下场景中变得重要的假设：

const a = new TreeObject();
const b = a.createObject('b');
const c = b.createObject('c');
const d = c.createLiteral('d');

a.watch(() => console.log("a resolved"));

d.set('foo'); // This triggers "a resolved"

// This makes a unresolved again
const e = c.createLiteral('e');
// but resolving a again will not trigger the same callback
e.set('bar'); // This does not trigger "a resolved" anymore
// Let's do that again: unresolve a...
const f = c.createLiteral('f');
// But now we add a new callback before the resolution occurs:
a.watch(() => console.log("a resolved AGAIN"));
f.set('baz'); // This triggers "a resolved AGAIN" (only)

这个假设意味着回调一旦被调用就可以/必须被 * 未注册 *。

• 如果在还没有文字时注册回调，则该对象将被视为 * 尚未 * 解析-要成为解析对象，（下游）对象结构中必须至少有一个文字，并且所有下游文字必须已接收值（或子集，如果提供Matcher对象）
• 如果提供了一个Matcher对象引用了一个不（完全）存在的结构，那么注册的回调将不会被调用，直到该结构已经 * 完全 * 构建，并且相应的文字已经接收到值。因此，我们需要一种“未决匹配器”属性，每当创建一个缺失的属性时，都需要检查该属性，以使一个或多个匹配器能够应用于该新属性。
• 如果Matcher对象有一个true值，而实际的对象结构有一个更深层次的嵌套对象结构，而不是一个文字，那么true将被解释为“所有低于此点”必须有接收值。
• 如果Matcher对象有一个对象，而实际对象有一个文字，则该匹配器将永远不会被解析。
• 我更新了这个答案，以便匹配器在端点节点上变成标准的观察者（没有匹配器），只要有可能（当相应的结构完成时），这样所有的都可以用计数器来管理，这些计数器从字面量向上更新到根。当计数器变为零时，意味着所有必要的项都已解决。这里一个重要的细节是，匹配器对象将为它的每个端点创建自己的回调，当这些回调被调用时，它将跟踪一个单独的计数器。当该值变为零时，将调用原始回调。

下面是如何编码的：

type Matcher = true | {
    [key: string]: Matcher
};

type Callback = () => void;

type Listener = { callback: Callback, matcher: Matcher };

type TreeNode = TreeObject | TreeLiteral;

abstract class TreeElement  {
    #parent?: TreeObject;
    #unresolvedCount = 0;
    #hasLiterals = false;
    #callbacks: Array<Callback> = [];
    
    constructor(parent?: TreeObject) {
        this.#parent = parent;
    }

    notify(isResolved: boolean) { // bubbles up from a TreeLiteral, when created and when resolved
        if (isResolved) {
            this.#unresolvedCount--;
            if (this.#unresolvedCount == 0) {
                for (const cb of this.#callbacks.splice(0)) {
                    cb();
                }
            }
        } else {
            this.#unresolvedCount++;
            this.#hasLiterals = true;
        }
        this.#parent?.notify(isResolved); // bubble up
    }
    
    watch(callback: Callback) {
        if (this.#hasLiterals && this.#unresolvedCount == 0) {
            callback();
        } else {
            this.#callbacks.push(callback);
        }
    }

}

class TreeObject extends TreeElement {
    #properties: Record<string, TreeNode> = {};
    #pendingMatchers: Record<string, Array<Listener>> = {};

    #attach(name: string, child: TreeNode) {
        this.#properties[name] = child;
        // If this name is used by one or more pending matchers, remove them as pending,
        //   and watch the nested matcher(s) on the newly created child.
        if (this.#pendingMatchers[name]) {
            for (const {callback, matcher} of this.#pendingMatchers[name].splice(0)) {
                child.watch(callback, matcher);
            }
        }
    }

    createObject(name: string) {
        if (this.#properties[name]) throw new Error(`Cannot create ${name}: it is already used`);
        const obj = new TreeObject(this);
        this.#attach(name, obj);
        return obj;
    }

    createLiteral(name: string) {
        if (this.#properties[name]) throw new Error(`Cannot create ${name}: it is already used`);
        const obj = new TreeLiteral(this);
        this.#attach(name, obj);
        return obj;
    }

    watch(callback: Callback, matcher: Matcher=true) {
        if (matcher === true) {
            super.watch(callback);
        } else {
            let counter = Object.keys(matcher).length;
            // Create a new callback that will call the original callback when all toplevel
            //   entries specified by the matcher have been resolved.
            const newCallback = () => {
                counter--;
                if (counter == 0) {
                    callback();
                }
            };
            for (const key of Object.keys(matcher)) {
                if (this.#properties[key]) {
                    this.#properties[key].watch(newCallback, matcher[key]);
                } else { // suspend the watch until the structure is there
                    (this.#pendingMatchers[key] ??= []).push({
                        callback: newCallback,
                        // Copy the matcher so the caller cannot mutate our matcher
                        matcher: JSON.parse(JSON.stringify(matcher[key]))
                    });
                }
            }
        }

    }
}

class TreeLiteral extends TreeElement {
    #literalValue: any;

    constructor(parent?: TreeObject) {
        super(parent);
        this.notify(false); // Notifiy to the ancestors that there is a new literal
    }

    set(value: any) {
        this.#literalValue = value;
        this.notify(true); // Notifiy to the ancestors that this literal resolved
    }

    valueOf() {
        return this.#literalValue;
    }

    watch(callback: Callback, matcher: Matcher=true) {
        if (matcher === true) {
            super.watch(callback);
        } // else, the matcher references an endpoint that will never be created
    }
}

在TS Playground上用一些测试功能看看吧