@alloy-js/core 0.21.0-dev.1 → 0.21.0-dev.10

package/test/refkey.test.ts

@@ -1,5 +1,5 @@
 import { expect, it } from "vitest";
-import { refkey } from "../src/refkey.js";
+import { refkey, REFKEYABLE, Refkeyable } from "../src/refkey.js";
 
 it("is stable when called with same values", () => {
   const obj = {};
@@ -30,3 +30,14 @@ it("can be called with no args and returns a fresh key", () => {
   const key2 = refkey();
   expect(key1).not.toBe(key2);
 });
+
+it("unwraps refkeyables", () => {
+  const obj = {};
+  const rk1 = refkey(obj);
+  const refkeyable: Refkeyable = {
+    [REFKEYABLE]() {
+      return rk1;
+    },
+  };
+  expect(refkey(refkeyable)).toBe(rk1);
+});

package/test/rendering/basic.test.tsx

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { Children } from "../../src/runtime/component.js";
+import { Children, RENDERABLE } from "../../src/runtime/component.js";
 import "../../testing/extend-expect.js";
 describe("string nodes", () => {
   it("renders string nodes with substitutions", () => {
@@ -49,6 +49,40 @@ describe("component nodes", () => {
       </>,
     ).toRenderTo("Str Str");
   });
+
+  it("renders custom elements", () => {
+    const customElement = {
+      [RENDERABLE]() {
+        return (
+          <>
+            <Str /> <Str />
+          </>
+        );
+      },
+    };
+
+    expect(customElement).toRenderTo("Str Str");
+  });
+
+  it("renders nested custom elements", () => {
+    const e1 = {
+      [RENDERABLE]() {
+        return <Str />;
+      },
+    };
+
+    const e2 = {
+      [RENDERABLE]() {
+        return (
+          <>
+            {e1} {e1}
+          </>
+        );
+      },
+    };
+
+    expect(e2).toRenderTo("Str Str");
+  });
 });
 
 describe("memo nodes", () => {

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"
   ],