@alloy-js/core 0.21.0-dev.3 → 0.21.0-dev.9

package/test/symbols/output-scope.test.ts

@@ -1,6 +1,6 @@
 import { reactive, watch } from "@vue/reactivity";
 import { describe, expect, it, vi } from "vitest";
-import { Refkey } from "../../src/refkey.js";
+import { refkey } from "../../src/refkey.js";
 import { flushJobs } from "../../src/scheduler.js";
 import { BasicScope } from "../../src/symbols/basic-scope.js";
 import { SymbolTable } from "../../src/symbols/symbol-table.js";
@@ -168,9 +168,9 @@ describe("OutputScope#symbolsByRefkey", () => {
 
     // Use the refkey function to create refkeys
     // This is based on how refkey is being imported in binder.ts
-    const key1 = "key1" as unknown as Refkey;
-    const key2a = "key2a" as unknown as Refkey;
-    const key2b = "key2b" as unknown as Refkey;
+    const key1 = refkey();
+    const key2a = refkey();
+    const key2b = refkey();
 
     // Create a symbol with a refkey
     const [sym1] = createSymbol("sym1", scope, {

package/test/symbols/resolution.test.ts

@@ -447,6 +447,47 @@ describe("resolving type members by refkey", () => {
     expect(result.memberPath).toEqual([staticProp]);
   });
 
+  it("string member", () => {
+    const globalScope = createScope("global");
+    const [typeSymbol, typeKey] = createSymbol("MyType", globalScope);
+    const [staticProp] = createSymbol("staticProp", typeSymbol.staticMembers);
+
+    // resolve a member of type
+    const result = binder.resolveDeclarationByKey(
+      globalScope,
+      memberRefkey(typeKey, "staticProp"),
+    ).value!;
+
+    expect(result.symbol).toBe(staticProp);
+    expect(result.lexicalDeclaration).toBe(typeSymbol);
+    expect(result.memberPath).toEqual([staticProp]);
+  });
+
+  it("string member when member symbol changes", async () => {
+    const globalScope = createScope("global");
+    const [typeSymbol, typeKey] = createSymbol("MyType", globalScope);
+    const [staticProp] = createSymbol("staticProp", typeSymbol.staticMembers);
+
+    // resolve a member of type
+    const result = binder.resolveDeclarationByKey(
+      globalScope,
+      memberRefkey(typeKey, "staticProp"),
+    );
+
+    expect(result.value!.symbol).toBe(staticProp);
+    expect(result.value!.lexicalDeclaration).toBe(typeSymbol);
+    expect(result.value!.memberPath).toEqual([staticProp]);
+
+    staticProp.delete();
+
+    expect(result.value).toBe(undefined);
+
+    const [staticProp2] = createSymbol("staticProp", typeSymbol.staticMembers);
+    expect(result.value!.symbol).toBe(staticProp2);
+    expect(result.value!.lexicalDeclaration).toBe(typeSymbol);
+    expect(result.value!.memberPath).toEqual([staticProp2]);
+  });
+
   it("nested member", () => {
     const globalScope = createScope("global");
     const [typeSymbol, typeKey] = createSymbol("MyType", globalScope);
@@ -472,7 +513,7 @@ describe("resolving type members by refkey", () => {
     // resolve from a member refkey
     const result2 = binder.resolveDeclarationByKey(
       globalScope,
-      memberRefkey(memberRefkey(typeKey, staticPropKey), nestedKey),
+      memberRefkey(typeKey, staticPropKey, nestedKey),
     ).value!;
 
     expect(result2.symbol).toBe(nestedProp);

package/testing/create-test-wrapper.tsx

@@ -0,0 +1,70 @@
+import {
+  Children,
+  Declaration,
+  For,
+  Namekey,
+  namekey,
+  Output,
+  OutputSymbol,
+  shallowReactive,
+} from "@alloy-js/core";
+
+export interface TestWrapper {
+  Wrapper: (props: { children: Children }) => Children;
+  defkey: (name: string) => Namekey;
+}
+
+/**
+ * Generic test wrapper creator.
+ */
+export function createTestWrapper<
+  SymbolT extends OutputSymbol,
+  ScopeT extends { spaces: any },
+>(opts: {
+  filePath: string;
+  useScope: () => ScopeT | undefined;
+  makeSymbol: (nk: Namekey, scope: ScopeT) => SymbolT;
+  SourceFile: (props: { path: string; children: Children }) => any;
+}): TestWrapper {
+  const seen = shallowReactive(new Map<string, Namekey>());
+  const created = new Map<Namekey, SymbolT>();
+
+  function defkey(name: string): Namekey {
+    const existing = seen.get(name);
+    if (existing) return existing;
+    const nk = namekey(name, {
+      ignoreNamePolicy: true,
+      ignoreNameConflict: true,
+    });
+    seen.set(name, nk);
+    return nk;
+  }
+
+  function createSymbol(nk: Namekey) {
+    const existing = created.get(nk);
+    if (existing) return existing;
+    const scope = opts.useScope();
+    if (!scope) {
+      throw new Error(`No SourceFile scope when declaring symbol: ${nk.name}`);
+    }
+    const sym = opts.makeSymbol(nk, scope);
+    created.set(nk, sym);
+    return sym;
+  }
+
+  function Wrapper(props: { children: Children }) {
+    const SF = opts.SourceFile;
+    return (
+      <Output>
+        <SF path={opts.filePath}>
+          <For each={[...seen.values()]} joiner="">
+            {(nk) => <Declaration symbol={createSymbol(nk)} />}
+          </For>
+          {props.children}
+        </SF>
+      </Output>
+    );
+  }
+
+  return { Wrapper, defkey } as const;
+}

package/testing/index.ts

@@ -1,2 +1,3 @@
 import "./extend-expect.js";
+export * from "./create-test-wrapper.jsx";
 export * from "./render.js";

package/tsconfig.json

@@ -11,6 +11,7 @@
     "test/**/*.ts",
     "test/**/*.tsx",
     "testing/**/*.ts",
+    "testing/**/*.tsx",
     "testing/**/*.d.ts",
     "testing/extend-expect.test.tsx"
   ],