@alloy-js/core 0.9.0 → 0.11.0

package/dist/test/symbols.test.js

@@ -0,0 +1,504 @@
+import { describe, expect, it } from "vitest";
+import { createOutputBinder, OutputScopeFlags, OutputSymbolFlags } from "../src/binder.js";
+import { refkey } from "../src/refkey.js";
+it("works", () => {
+  const binder = createOutputBinder();
+  const scope = binder.createScope({
+    kind: "foo",
+    name: "scope",
+    parent: binder.globalScope
+  });
+  const symbol = binder.createSymbol({
+    name: "sym",
+    scope
+  });
+  expect([...scope.getSymbolNames()]).toEqual(["sym"]);
+  symbol.name = "bar";
+  expect([...scope.getSymbolNames()]).toEqual(["bar"]);
+});
+it("resolves symbol conflicts", () => {
+  const binder = createOutputBinder();
+  const scope = binder.createScope({
+    kind: "foo",
+    name: "scope",
+    parent: binder.globalScope
+  });
+  const _s1 = binder.createSymbol({
+    name: "sym",
+    scope
+  });
+  const s2 = binder.createSymbol({
+    name: "sym",
+    scope
+  });
+  expect(s2.name).toEqual("sym_2");
+});
+function createScopeTree(binder, tree) {
+  const createdItems = {
+    symbols: {},
+    scopes: {}
+  };
+  for (const [name, desc] of Object.entries(tree)) {
+    createScope(name, desc);
+  }
+  return createdItems;
+  function createScope(name, descriptor, parent = binder.globalScope) {
+    const scope = binder.createScope({
+      kind: "useless",
+      name,
+      parent,
+      flags: descriptor.flags ?? OutputScopeFlags.None
+    });
+    createdItems.scopes[name] = scope;
+    for (const [name, desc] of Object.entries(descriptor.symbols)) {
+      createSymbol(name, desc, scope);
+    }
+    for (const [name, desc] of Object.entries(descriptor.scopes ?? {})) {
+      createScope(name, desc, scope);
+    }
+  }
+  function createSymbol(name, descriptor, parent) {
+    const symbol = binder.createSymbol({
+      name,
+      scope: parent,
+      refkey: descriptor.refkey ?? refkey(),
+      flags: descriptor.flags ?? OutputSymbolFlags.None
+    });
+    createdItems.symbols[name] = symbol;
+    if (descriptor.instanceMembers) {
+      for (const [name, desc] of Object.entries(descriptor.instanceMembers)) {
+        createSymbol(name, desc, symbol.instanceMemberScope);
+      }
+    }
+    if (descriptor.staticMembers) {
+      for (const [name, desc] of Object.entries(descriptor.staticMembers)) {
+        createSymbol(name, desc, symbol.staticMemberScope);
+      }
+    }
+  }
+}
+describe("static members", () => {
+  it("resolves static symbols", () => {
+    const binder = createOutputBinder();
+    const {
+      scopes: {
+        root
+      },
+      symbols: {
+        root: rootSym,
+        static: staticSym
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer | OutputSymbolFlags.StaticMemberContainer,
+            staticMembers: {
+              static: {
+                flags: OutputSymbolFlags.StaticMember
+              }
+            }
+          }
+        }
+      }
+    });
+    const resolution = binder.resolveDeclarationByKey(root, undefined, staticSym.refkeys[0]);
+    expect(resolution.value).toBeDefined();
+    const {
+      commonScope,
+      pathUp,
+      pathDown,
+      targetDeclaration,
+      memberPath
+    } = resolution.value;
+    expect(commonScope).toBe(root);
+    expect(targetDeclaration).toBe(rootSym);
+    expect(pathDown).toEqual([]);
+    expect(pathUp).toEqual([]);
+    expect(memberPath.map(s => s.name)).toEqual(["root", "static"]);
+  });
+  it("resolves deeply nested static symbols", () => {
+    const binder = createOutputBinder();
+    const {
+      scopes: {
+        root
+      },
+      symbols: {
+        root: rootSym,
+        nested_static
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer | OutputSymbolFlags.StaticMemberContainer,
+            staticMembers: {
+              static: {
+                flags: OutputSymbolFlags.StaticMember | OutputSymbolFlags.StaticMemberContainer,
+                staticMembers: {
+                  nested_static: {
+                    flags: OutputSymbolFlags.StaticMember
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    });
+    const resolution = binder.resolveDeclarationByKey(root, undefined, nested_static.refkeys[0]);
+    expect(resolution.value).toBeDefined();
+    const {
+      commonScope,
+      pathUp,
+      pathDown,
+      targetDeclaration,
+      memberPath
+    } = resolution.value;
+    expect(commonScope).toBe(root);
+    expect(targetDeclaration).toBe(rootSym);
+    expect(pathDown).toEqual([]);
+    expect(pathUp).toEqual([]);
+    expect(memberPath.map(s => s.name)).toEqual(["root", "static", "nested_static"]);
+  });
+  it("resolves static symbols lazily", () => {
+    const staticSymRefkey = refkey();
+    const binder = createOutputBinder();
+    const {
+      scopes: {
+        root
+      },
+      symbols: {
+        root: rootSym
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer | OutputSymbolFlags.StaticMemberContainer
+          }
+        }
+      }
+    });
+    const resolution = binder.resolveDeclarationByKey(root, undefined, staticSymRefkey);
+    expect(resolution.value).toBeUndefined();
+    binder.createSymbol({
+      name: "static",
+      scope: rootSym.staticMemberScope,
+      refkey: staticSymRefkey,
+      flags: OutputSymbolFlags.StaticMember
+    });
+    expect(resolution.value).toBeDefined();
+    const {
+      commonScope,
+      pathUp,
+      pathDown,
+      targetDeclaration,
+      memberPath
+    } = resolution.value;
+    expect(commonScope).toBe(root);
+    expect(targetDeclaration).toBe(rootSym);
+    expect(pathDown).toEqual([]);
+    expect(pathUp).toEqual([]);
+    expect(memberPath.map(s => s.name)).toEqual(["root", "static"]);
+  });
+});
+describe("instance members", () => {
+  it("resolves", () => {
+    const binder = createOutputBinder();
+    const {
+      symbols: {
+        root: rootSym,
+        instance
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instance: {
+                flags: OutputSymbolFlags.InstanceMember
+              }
+            }
+          }
+        }
+      }
+    });
+    const resolution = binder.resolveDeclarationByKey(undefined, rootSym.instanceMemberScope, instance.refkeys[0]);
+    expect(resolution.value).toBeDefined();
+    const {
+      commonScope,
+      pathUp,
+      pathDown,
+      targetDeclaration,
+      memberPath
+    } = resolution.value;
+    expect(commonScope).toBe(rootSym.instanceMemberScope);
+    expect(targetDeclaration).toBe(instance);
+    expect(pathDown).toEqual([]);
+    expect(pathUp).toEqual([]);
+    expect(memberPath).toEqual([instance]);
+  });
+});
+describe("instantiating members", () => {
+  it("instantiates static symbols", () => {
+    const binder = createOutputBinder();
+    const {
+      symbols: {
+        rootSymbol,
+        instance,
+        instantiation
+      }
+    } = createScopeTree(binder, {
+      rootScope: {
+        symbols: {
+          rootSymbol: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instance: {
+                flags: OutputSymbolFlags.StaticMember
+              }
+            }
+          },
+          instantiation: {}
+        }
+      }
+    });
+    binder.instantiateSymbolInto(rootSymbol, instantiation);
+    expect(instantiation.flags & OutputSymbolFlags.InstanceMemberContainer).toBeTruthy();
+    expect(instantiation.instanceMemberScope).toBeDefined();
+    const expectedRefkey = refkey(instantiation.refkeys[0], instance.refkeys[0]);
+    expect(instantiation.instanceMemberScope.symbolsByRefkey.get(expectedRefkey)).toBeDefined();
+  });
+  it("instantiates static symbols that are added after the instantiation", () => {
+    const binder = createOutputBinder();
+    const {
+      symbols: {
+        rootSymbol,
+        instance,
+        instantiation
+      }
+    } = createScopeTree(binder, {
+      rootScope: {
+        symbols: {
+          rootSymbol: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instance: {
+                flags: OutputSymbolFlags.StaticMember
+              }
+            }
+          },
+          instantiation: {}
+        }
+      }
+    });
+    binder.instantiateSymbolInto(rootSymbol, instantiation);
+    expect(instantiation.flags & OutputSymbolFlags.InstanceMemberContainer).toBeTruthy();
+    expect(instantiation.instanceMemberScope).toBeDefined();
+    const expectedRefkey = refkey(instantiation.refkeys[0], instance.refkeys[0]);
+    expect(instantiation.instanceMemberScope.symbolsByRefkey.get(expectedRefkey)).toBeDefined();
+    const newInstanceMemberRefkey = refkey();
+    binder.createSymbol({
+      name: "newInstanceMember",
+      scope: rootSymbol.instanceMemberScope,
+      refkey: newInstanceMemberRefkey,
+      flags: OutputSymbolFlags.InstanceMember
+    });
+    const newExpectedRefkey = refkey(instantiation.refkeys[0], newInstanceMemberRefkey);
+    expect(instantiation.instanceMemberScope.symbolsByRefkey.get(newExpectedRefkey)).toBeDefined();
+  });
+});
+describe("symbol name resolution", () => {
+  it("resolves static symbols", () => {
+    const binder = createOutputBinder();
+    const {
+      symbols: {
+        static: staticSym
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer | OutputSymbolFlags.StaticMemberContainer,
+            staticMembers: {
+              static: {
+                flags: OutputSymbolFlags.StaticMember
+              }
+            }
+          }
+        }
+      }
+    });
+    const result = binder.resolveFQN("root.root.static");
+    expect(result.value).toEqual(staticSym);
+  });
+  it("resolves static symbols that are added later", () => {
+    const binder = createOutputBinder();
+    const result = binder.resolveFQN("root.root.static");
+    expect(result.value).toBeUndefined();
+    const {
+      symbols: {
+        static: staticSym
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer | OutputSymbolFlags.StaticMemberContainer,
+            staticMembers: {
+              static: {
+                flags: OutputSymbolFlags.StaticMember
+              }
+            }
+          }
+        }
+      }
+    });
+    expect(result.value).toEqual(staticSym);
+  });
+  it("resolves instance symbols", () => {
+    const binder = createOutputBinder();
+    const {
+      symbols: {
+        instance
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instance: {
+                flags: OutputSymbolFlags.InstanceMember
+              }
+            }
+          }
+        }
+      }
+    });
+    const result = binder.resolveFQN("root.root#instance");
+    expect(result.value).toEqual(instance);
+  });
+  it("resolves instance symbols that are added later", () => {
+    const binder = createOutputBinder();
+    const result = binder.resolveFQN("root.root#instance");
+    expect(result.value).toBeUndefined();
+    const {
+      symbols: {
+        instance
+      }
+    } = createScopeTree(binder, {
+      root: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer,
+            instanceMembers: {
+              instance: {
+                flags: OutputSymbolFlags.InstanceMember
+              }
+            }
+          }
+        }
+      }
+    });
+    expect(result.value).toEqual(instance);
+  });
+});
+describe("refkey resolution", () => {
+  it("resolves existing symbols by refkey", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const sym = binder.createSymbol({
+      name: "foo",
+      refkey: key,
+      scope: binder.globalScope
+    });
+    const resolvedSym = binder.resolveDeclarationByKey(undefined, undefined, key);
+    expect(resolvedSym.value?.targetDeclaration).toBe(sym);
+  });
+  it("resolves symbols by refkey when symbol is added later", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const resolvedSym = binder.resolveDeclarationByKey(undefined, undefined, key);
+    const sym = binder.createSymbol({
+      name: "foo",
+      refkey: key,
+      scope: binder.globalScope
+    });
+    expect(resolvedSym.value?.targetDeclaration).toBe(sym);
+  });
+  it("resolves symbols by refkey when refkey is added later", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const resolvedSym = binder.resolveDeclarationByKey(undefined, undefined, key);
+    const sym = binder.createSymbol({
+      name: "foo",
+      scope: binder.globalScope
+    });
+    expect(resolvedSym.value).toBe(undefined);
+    sym.refkeys[0] = key;
+    expect(resolvedSym.value?.targetDeclaration).toBe(sym);
+  });
+});
+describe("Deleting symbols", () => {
+  it("updates resolutions", () => {
+    const key = refkey();
+    const binder = createOutputBinder();
+    const resolvedSym = binder.resolveDeclarationByKey(undefined, undefined, key);
+    const sym = binder.createSymbol({
+      name: "foo",
+      scope: binder.globalScope
+    });
+    expect(resolvedSym.value).toBe(undefined);
+    sym.refkeys[0] = key;
+    expect(resolvedSym.value?.targetDeclaration).toBe(sym);
+    binder.deleteSymbol(sym);
+    expect(resolvedSym.value).toBe(undefined);
+  });
+  it("removes from parent scopes", () => {
+    const binder = createOutputBinder();
+    const result = binder.resolveFQN("root.root#instance");
+    expect(result.value).toBeUndefined();
+    const {
+      symbols: {
+        instance,
+        root,
+        staticc
+      },
+      scopes: {
+        rootScope
+      }
+    } = createScopeTree(binder, {
+      rootScope: {
+        symbols: {
+          root: {
+            flags: OutputSymbolFlags.InstanceMemberContainer | OutputSymbolFlags.StaticMemberContainer,
+            instanceMembers: {
+              instance: {
+                flags: OutputSymbolFlags.InstanceMember
+              }
+            },
+            staticMembers: {
+              staticc: {
+                flags: OutputSymbolFlags.StaticMember
+              }
+            }
+          }
+        }
+      }
+    });
+    const staticScope = root.staticMemberScope;
+    const instanceScope = root.instanceMemberScope;
+    expect(staticScope.symbols.size).toBe(1);
+    binder.deleteSymbol(staticc);
+    expect(staticScope.symbols.size).toBe(0);
+    expect(instanceScope.symbols.size).toBe(1);
+    binder.deleteSymbol(instance);
+    expect(instanceScope.symbols.size).toBe(0);
+    expect(rootScope.symbols.size).toBe(1);
+    binder.deleteSymbol(root);
+    expect(rootScope.symbols.size).toBe(0);
+  });
+});

package/dist/test/utils.test.js

@@ -0,0 +1,221 @@
+import { memo as _$memo, createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { computed, ref, triggerRef } from "@vue/reactivity";
+import { describe, expect, it } from "vitest";
+import { renderTree } from "../src/render.js";
+import { children, join, mapJoin } from "../src/utils.js";
+import "../testing/extend-expect.js";
+describe("mapJoin", () => {
+  it("can map a map", () => {
+    const map = new Map([["a", 1], ["b", 2]]);
+    function Foo(props) {
+      return ["Key: ", _$memo(() => props.key), ", Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => map, (key, value) => _$createComponent(Foo, {
+      key: key,
+      value: value
+    }));
+    expect(joined()).toRenderTo(`
+      Key: a, Value: 1
+      Key: b, Value: 2
+    `);
+  });
+  it("can map an array", () => {
+    const arr = [1, 2];
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => arr, value => _$createComponent(Foo, {
+      value: value
+    }));
+    expect(joined()).toRenderTo(`
+      Value: 1
+      Value: 2
+    `);
+  });
+  it("can map an array reactively (without render)", () => {
+    const arr = ref([1, 2]);
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => arr.value, value => {
+      return _$createComponent(Foo, {
+        value: value
+      });
+    });
+    const len = computed(() => {
+      return joined().length;
+    });
+    expect(len.value).toBe(4);
+    arr.value.push(3);
+    triggerRef(arr);
+    expect(len.value).toBe(6);
+  });
+  it("can map an array reactively (with render)", () => {
+    let callCount = 0;
+    const arr = ref([1, 2]);
+    function Foo(props) {
+      callCount++;
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => arr.value, value => {
+      return _$createComponent(Foo, {
+        value: value
+      });
+    });
+    renderTree(joined);
+    expect(callCount).toBe(2);
+    arr.value.push(3);
+    triggerRef(arr);
+    expect(callCount).toBe(3);
+  });
+  it("can map a joiner", () => {
+    const arr = [1, 2];
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => arr, value => _$createComponent(Foo, {
+      value: value
+    }), {
+      joiner: "-"
+    });
+    expect(joined).toRenderTo(`
+      Value: 1-Value: 2
+    `);
+  });
+  it("can map an ender", () => {
+    const arr = [1, 2];
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => arr, value => _$createComponent(Foo, {
+      value: value
+    }), {
+      joiner: "-",
+      ender: ";"
+    });
+    expect(joined).toRenderTo(`
+      Value: 1-Value: 2;
+    `);
+  });
+  it("can map using an iterator", () => {
+    const arr = [1, 2].values();
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => arr, value => _$createComponent(Foo, {
+      value: value
+    }), {
+      joiner: "-",
+      ender: ";"
+    });
+    expect(joined).toRenderTo(`
+      Value: 1-Value: 2;
+    `);
+  });
+});
+describe("join", () => {
+  it("can join an array", () => {
+    const arr = [_$createComponent(Foo, {
+      value: 1
+    }), _$createComponent(Foo, {
+      value: 2
+    })];
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = join(arr);
+    expect(joined).toRenderTo(`
+      Value: 1
+      Value: 2
+    `);
+  });
+  it("can join an array with a joiner", () => {
+    const arr = [_$createComponent(Foo, {
+      value: 1
+    }), _$createComponent(Foo, {
+      value: 2
+    })];
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = join(arr, {
+      joiner: "-"
+    });
+    expect(joined).toRenderTo(`
+      Value: 1-Value: 2
+    `);
+  });
+  it("can join an array with an ender", () => {
+    const arr = [_$createComponent(Foo, {
+      value: 1
+    }), _$createComponent(Foo, {
+      value: 2
+    })];
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = join(arr, {
+      joiner: "-",
+      ender: ";"
+    });
+    expect(joined).toRenderTo(`
+      Value: 1-Value: 2;
+    `);
+  });
+  it("can join using an iterator", () => {
+    const arrIter = [_$createComponent(Foo, {
+      value: 1
+    }), _$createComponent(Foo, {
+      value: 2
+    })].values();
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = join(arrIter, {
+      joiner: "-",
+      ender: ";"
+    });
+    expect(joined).toRenderTo(`
+      Value: 1-Value: 2;
+    `);
+  });
+});
+describe("children", () => {
+  let resolvedChildren;
+  function ResolveChildren(props) {
+    resolvedChildren = children(() => props.children, {
+      preserveFragments: props.preserveFragments
+    })();
+  }
+  it("resolves a single child", () => {
+    renderTree(_$createComponent(ResolveChildren, {
+      children: "1"
+    }));
+    expect(resolvedChildren).toEqual("1");
+  });
+  it("resolves multiple children", () => {
+    renderTree(_$createComponent(ResolveChildren, {
+      get children() {
+        return ["1", "2", "3"];
+      }
+    }));
+    expect(resolvedChildren).toEqual(["1", "2", "3"]);
+  });
+  it("resolves fragments by default", () => {
+    renderTree(_$createComponent(ResolveChildren, {
+      get children() {
+        return [["1"], ["2"], ["3"]];
+      }
+    }));
+    expect(resolvedChildren).toEqual(["1", "2", "3"]);
+  });
+  it("preserves fragments if asked", () => {
+    renderTree(_$createComponent(ResolveChildren, {
+      preserveFragments: true,
+      get children() {
+        return [["1"], ["2"], ["3"]];
+      }
+    }));
+    expect(resolvedChildren).toEqual([["1"], ["2"], ["3"]]);
+  });
+});