@alloy-js/core 0.11.0 → 0.13.0

package/dist/test/symbols.test.js

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 import { createOutputBinder, OutputScopeFlags, OutputSymbolFlags } from "../src/binder.js";
 import { refkey } from "../src/refkey.js";
+import { flushJobs } from "../src/scheduler.js";
 it("works", () => {
   const binder = createOutputBinder();
   const scope = binder.createScope({
@@ -12,8 +13,10 @@ it("works", () => {
     name: "sym",
     scope
   });
+  flushJobs();
   expect([...scope.getSymbolNames()]).toEqual(["sym"]);
   symbol.name = "bar";
+  flushJobs();
   expect([...scope.getSymbolNames()]).toEqual(["bar"]);
 });
 it("resolves symbol conflicts", () => {
@@ -31,7 +34,14 @@ it("resolves symbol conflicts", () => {
     name: "sym",
     scope
   });
+  const s3 = binder.createSymbol({
+    name: "sym",
+    scope
+  });
+  flushJobs();
+  expect(_s1.name).toEqual("sym");
   expect(s2.name).toEqual("sym_2");
+  expect(s3.name).toEqual("sym_3");
 });
 function createScopeTree(binder, tree) {
   const createdItems = {
@@ -242,8 +252,25 @@ describe("instance members", () => {
   });
 });
 describe("instantiating members", () => {
-  it("instantiates static symbols", () => {
+  it("instantiates instance members", () => {
     const binder = createOutputBinder();
+
+    /**
+     * The following structure would match code like this:
+     * ```ts
+     * // A class with instance members
+     * class Source {
+     *   instance() {
+     *     print("instance");
+     *   }
+     * }
+     *
+     * // Instantiates into t
+     * var t = new Source();
+     *
+     * t.instance();
+     * ```
+     */
     const {
       symbols: {
         rootSymbol,
@@ -257,7 +284,7 @@ describe("instantiating members", () => {
             flags: OutputSymbolFlags.InstanceMemberContainer,
             instanceMembers: {
               instance: {
-                flags: OutputSymbolFlags.StaticMember
+                flags: OutputSymbolFlags.InstanceMember
               }
             }
           },
@@ -266,12 +293,89 @@ describe("instantiating members", () => {
       }
     });
     binder.instantiateSymbolInto(rootSymbol, instantiation);
-    expect(instantiation.flags & OutputSymbolFlags.InstanceMemberContainer).toBeTruthy();
-    expect(instantiation.instanceMemberScope).toBeDefined();
+    expect(instantiation.flags & OutputSymbolFlags.StaticMemberContainer).toBeTruthy();
+    expect(instantiation.staticMemberScope).toBeDefined();
     const expectedRefkey = refkey(instantiation.refkeys[0], instance.refkeys[0]);
-    expect(instantiation.instanceMemberScope.symbolsByRefkey.get(expectedRefkey)).toBeDefined();
+    expect(instantiation.staticMemberScope.symbolsByRefkey.get(expectedRefkey)).toBeDefined();
+  });
+  it("doesn't duplicate symbols", () => {
+    const binder = createOutputBinder();
+    const {
+      symbols: {
+        rootSymbol,
+        instantiation
+      }
+    } = createScopeTree(binder, {
+      rootScope: {
+        symbols: {
+          rootSymbol: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instance: {
+                flags: OutputSymbolFlags.InstanceMember
+              }
+            }
+          },
+          instantiation: {}
+        }
+      }
+    });
+    binder.instantiateSymbolInto(rootSymbol, instantiation);
+    flushJobs();
+    expect(instantiation.staticMemberScope.symbols.size).toBe(1);
+    const lateKey = refkey();
+    // now add a brand‐new static member to source
+    binder.createSymbol({
+      name: "lateChild",
+      scope: rootSymbol.instanceMemberScope,
+      refkey: lateKey,
+      flags: OutputSymbolFlags.InstanceMember
+    });
+    flushJobs();
+    expect(rootSymbol.instanceMemberScope.symbols.size).toBe(2);
+    expect(instantiation.staticMemberScope.symbols.size).toBe(2);
+  });
+  it("should remove members in instance when source deleted them", () => {
+    const binder = createOutputBinder();
+    const {
+      symbols: {
+        rootSymbol,
+        instantiation
+      }
+    } = createScopeTree(binder, {
+      rootScope: {
+        symbols: {
+          rootSymbol: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instance: {
+                flags: OutputSymbolFlags.InstanceMember
+              }
+            }
+          },
+          instantiation: {}
+        }
+      }
+    });
+    binder.instantiateSymbolInto(rootSymbol, instantiation);
+    expect(instantiation.staticMemberScope.symbols.size).toBe(1);
+    const lateKey = refkey();
+    // now add a brand‐new static member to source
+    binder.createSymbol({
+      name: "lateChild",
+      scope: rootSymbol.instanceMemberScope,
+      refkey: lateKey,
+      flags: OutputSymbolFlags.InstanceMember
+    });
+    flushJobs();
+    expect(rootSymbol.instanceMemberScope.symbols.size).toBe(2);
+    expect(instantiation.staticMemberScope.symbols.size).toBe(2);
+    binder.deleteSymbol(rootSymbol.instanceMemberScope.symbols.values().next().value);
+    flushJobs();
+    expect(rootSymbol.instanceMemberScope.symbols.size).toBe(1);
+    expect(instantiation.staticMemberScope.symbols.size).toBe(1);
   });
-  it("instantiates static symbols that are added after the instantiation", () => {
+  it("instantiates instance members added after the instantiation", () => {
     const binder = createOutputBinder();
     const {
       symbols: {
@@ -286,7 +390,7 @@ describe("instantiating members", () => {
             flags: OutputSymbolFlags.InstanceMemberContainer,
             instanceMembers: {
               instance: {
-                flags: OutputSymbolFlags.StaticMember
+                flags: OutputSymbolFlags.InstanceMember
               }
             }
           },
@@ -295,10 +399,11 @@ describe("instantiating members", () => {
       }
     });
     binder.instantiateSymbolInto(rootSymbol, instantiation);
-    expect(instantiation.flags & OutputSymbolFlags.InstanceMemberContainer).toBeTruthy();
-    expect(instantiation.instanceMemberScope).toBeDefined();
+    flushJobs();
+    expect(instantiation.flags & OutputSymbolFlags.StaticMemberContainer).toBeTruthy();
+    expect(instantiation.staticMemberScope).toBeDefined();
     const expectedRefkey = refkey(instantiation.refkeys[0], instance.refkeys[0]);
-    expect(instantiation.instanceMemberScope.symbolsByRefkey.get(expectedRefkey)).toBeDefined();
+    expect(instantiation.staticMemberScope.symbolsByRefkey.get(expectedRefkey)).toBeDefined();
     const newInstanceMemberRefkey = refkey();
     binder.createSymbol({
       name: "newInstanceMember",
@@ -307,7 +412,279 @@ describe("instantiating members", () => {
       flags: OutputSymbolFlags.InstanceMember
     });
     const newExpectedRefkey = refkey(instantiation.refkeys[0], newInstanceMemberRefkey);
-    expect(instantiation.instanceMemberScope.symbolsByRefkey.get(newExpectedRefkey)).toBeDefined();
+    flushJobs();
+    expect(instantiation.staticMemberScope.symbolsByRefkey.get(newExpectedRefkey)).toBeDefined();
+  });
+  it("instantiates static symbols for a static container source", () => {
+    const binder = createOutputBinder();
+
+    /**
+     * The following structure would match code like this:
+     * ```ts
+     * // A class with instance members
+     * class Source {
+     *   static child() {
+     *     print("child");
+     *   }
+     * }
+     *
+     *
+     * var printChild = Source.child;
+     *
+     * printChild();
+     * ```
+     */
+    const {
+      symbols: {
+        source,
+        child,
+        target
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          source: {
+            flags: OutputSymbolFlags.StaticMemberContainer,
+            staticMembers: {
+              child: {
+                flags: OutputSymbolFlags.StaticMember
+              }
+            }
+          },
+          target: {}
+        }
+      }
+    });
+    binder.instantiateSymbolInto(source, target);
+
+    // target must now be a StaticMemberContainer too
+    expect(target.flags & OutputSymbolFlags.StaticMemberContainer).toBeTruthy();
+    expect(target.staticMemberScope).toBeDefined();
+    const expectedKey = refkey(target.refkeys[0], child.refkeys[0]);
+    expect(target.staticMemberScope.symbolsByRefkey.get(expectedKey)).toBeDefined();
+  });
+  it("instantiates static symbols added after instantiation", () => {
+    const binder = createOutputBinder();
+    const lateKey = refkey();
+    const {
+      symbols: {
+        source,
+        target
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          source: {
+            flags: OutputSymbolFlags.StaticMemberContainer
+          },
+          target: {}
+        }
+      }
+    });
+
+    // hook up instantiation
+    binder.instantiateSymbolInto(source, target);
+
+    // now add a brand‐new static member to source
+    const late = binder.createSymbol({
+      name: "lateChild",
+      scope: source.staticMemberScope,
+      refkey: lateKey,
+      flags: OutputSymbolFlags.StaticMember
+    });
+    flushJobs();
+
+    // it should *automatically* show up on target.staticMemberScope
+    const expectedKey = refkey(target.refkeys[0], late.refkeys[0]);
+    expect(target.staticMemberScope.symbolsByRefkey.get(expectedKey)).toBeDefined();
+  });
+  it("recursively instantiates nested static members", () => {
+    const binder = createOutputBinder();
+
+    /**
+     * The following structure would match code like this:
+     * ```ts
+     *   class Source {
+     *     static Level1 = class {
+     *       static level2() { print("deep"); }
+     *     }
+     *   }
+     *
+     *   var target = Source;
+     *
+     *   target.Level1.level2()
+     * ```
+     */
+    const {
+      symbols: {
+        source,
+        level1,
+        level2,
+        target
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          source: {
+            flags: OutputSymbolFlags.StaticMemberContainer,
+            staticMembers: {
+              level1: {
+                flags: OutputSymbolFlags.StaticMember | OutputSymbolFlags.StaticMemberContainer,
+                staticMembers: {
+                  level2: {
+                    flags: OutputSymbolFlags.StaticMember
+                  }
+                }
+              }
+            }
+          },
+          target: {}
+        }
+      }
+    });
+    binder.instantiateSymbolInto(source, target);
+
+    // level1 should appear under target.staticMemberScope
+    const key1 = refkey(target.refkeys[0], level1.refkeys[0]);
+    const instantiated1 = target.staticMemberScope.symbolsByRefkey.get(key1);
+    expect(instantiated1.name).toBe(level1.name);
+
+    // and level2 should appear under the *child* staticMemberScope of that instantiated level1
+    const childScope = instantiated1.staticMemberScope;
+    const key2 = refkey(instantiated1.refkeys[0], level2.refkeys[0]);
+    expect(childScope.symbolsByRefkey.get(key2)).toBeDefined();
+  });
+  it("copies both instance *and* static members when source has both flags", () => {
+    const binder = createOutputBinder();
+
+    /**
+     * ```ts
+     *   class Source {
+     *     instance() { print("inst"); }
+     *     static s1()  { print("static"); }
+     *   }
+     *
+     *   let t = new Source()
+     *   t.instance()
+     *   t.s1()
+     * ```
+     */
+    const {
+      symbols: {
+        source,
+        inst
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          source: {
+            flags: OutputSymbolFlags.InstanceMemberContainer | OutputSymbolFlags.StaticMemberContainer,
+            instanceMembers: {
+              i1: {
+                flags: OutputSymbolFlags.InstanceMember
+              }
+            },
+            staticMembers: {
+              s1: {
+                flags: OutputSymbolFlags.StaticMember
+              }
+            }
+          },
+          inst: {}
+        }
+      }
+    });
+    binder.instantiateSymbolInto(source, inst);
+    expect(inst.staticMemberScope).toBeDefined();
+    expect([...inst.staticMemberScope.symbols].some(s => s.name === "i1")).toBe(true);
+
+    // static side
+    const symbols = [...source.staticMemberScope.symbols];
+    expect(inst.staticMemberScope).toBeDefined();
+    const sKey = refkey(inst.refkeys[0], symbols[0].refkeys[0]);
+    expect(inst.staticMemberScope.symbolsByRefkey.has(sKey)).toBe(true);
+  });
+  it("is idempotent, calling twice does not duplicate", () => {
+    const binder = createOutputBinder();
+    const {
+      symbols: {
+        source,
+        target
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          source: {
+            flags: OutputSymbolFlags.StaticMemberContainer,
+            staticMembers: {
+              a: {
+                flags: OutputSymbolFlags.StaticMember
+              }
+            }
+          },
+          target: {}
+        }
+      }
+    });
+    binder.instantiateSymbolInto(source, target);
+    flushJobs();
+    const initialCount = target.staticMemberScope.symbols.size;
+    binder.instantiateSymbolInto(source, target);
+    flushJobs();
+    expect(target.staticMemberScope.symbols.size).toBe(initialCount);
+  });
+  it("instantiates static children of instance members under the instance scope", () => {
+    const binder = createOutputBinder();
+    /**
+     * ```ts
+     *    class Source {
+     *     instM = class {
+     *       static deep() { print("deep"); }
+     *     }
+     *    }
+     *
+     *   var t = new Source();
+     *   t.instM.deep();
+     * ```
+     */
+    const {
+      symbols: {
+        source,
+        deep,
+        target
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          source: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instM: {
+                flags: OutputSymbolFlags.InstanceMember | OutputSymbolFlags.StaticMemberContainer,
+                staticMembers: {
+                  deep: {
+                    flags: OutputSymbolFlags.StaticMember
+                  }
+                }
+              }
+            }
+          },
+          target: {}
+        }
+      }
+    });
+    binder.instantiateSymbolInto(source, target);
+
+    // Find the instantiated copy of instM under target.instanceMemberScope
+    const instMSym = [...target.staticMemberScope.symbols].find(s => s.name === "instM");
+
+    // instMSym should have gotten its own staticMemberScope via the StaticMemberContainer flag
+    expect(instMSym.staticMemberScope).toBeDefined();
+
+    // compute the expected key for the deep child:
+    //    (<target>, <instM>)  then (on that)  (<deep original>)
+    const expectedDeepKey = refkey(instMSym.refkeys[0], deep.refkeys[0]);
+    expect(instMSym.staticMemberScope.symbolsByRefkey.has(expectedDeepKey)).toBe(true);
   });
 });
 describe("symbol name resolution", () => {
@@ -439,6 +816,7 @@ describe("refkey resolution", () => {
     });
     expect(resolvedSym.value).toBe(undefined);
     sym.refkeys[0] = key;
+    flushJobs();
     expect(resolvedSym.value?.targetDeclaration).toBe(sym);
   });
 });
@@ -453,8 +831,10 @@ describe("Deleting symbols", () => {
     });
     expect(resolvedSym.value).toBe(undefined);
     sym.refkeys[0] = key;
+    flushJobs();
     expect(resolvedSym.value?.targetDeclaration).toBe(sym);
     binder.deleteSymbol(sym);
+    flushJobs();
     expect(resolvedSym.value).toBe(undefined);
   });
   it("removes from parent scopes", () => {

package/dist/test/utils.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../test/utils.test.tsx"],"names":[],"mappings":"AAKA,OAAO,6BAA6B,CAAC"}
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../test/utils.test.tsx"],"names":[],"mappings":"AAMA,OAAO,6BAA6B,CAAC"}

package/dist/test/utils.test.js

@@ -2,6 +2,7 @@ import { memo as _$memo, createComponent as _$createComponent } from "@alloy-js/
 import { computed, ref, triggerRef } from "@vue/reactivity";
 import { describe, expect, it } from "vitest";
 import { renderTree } from "../src/render.js";
+import { flushJobs } from "../src/scheduler.js";
 import { children, join, mapJoin } from "../src/utils.js";
 import "../testing/extend-expect.js";
 describe("mapJoin", () => {
@@ -66,6 +67,7 @@ describe("mapJoin", () => {
     expect(callCount).toBe(2);
     arr.value.push(3);
     triggerRef(arr);
+    flushJobs();
     expect(callCount).toBe(3);
   });
   it("can map a joiner", () => {