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

package/src/symbols/output-symbol.ts

@@ -94,6 +94,11 @@ export interface OutputSymbolOptions {
    * also ignoring name conflict resolution.
    */
   ignoreNameConflict?: boolean;
+
+  /**
+   * Provide a function which lazy-initializes members when an enumeration of members are needed.
+   */
+  lazyMemberInitializer?: () => void;
 }
 
 let symbolCount = 0;
@@ -459,6 +464,40 @@ export abstract class OutputSymbol {
     return this.#namePolicy;
   }
 
+  #lazyMemberInitializer: (() => void) | undefined;
+  #lazyMembersInitialized: boolean = false;
+
+  #initializeMembers() {
+    if (this.#lazyMemberInitializer && !this.#lazyMembersInitialized) {
+      this.#lazyMemberInitializer();
+    }
+    this.#lazyMembersInitialized = true;
+  }
+
+  /**
+   * Get a member symbol by name from this symbol's member spaces. Checks member
+   * spaces in order until it finds a member with that name.
+   */
+  resolveMemberByName(name: string): OutputSymbol | undefined {
+    this.#initializeMembers();
+
+    if (this.isTyped) {
+      if (!this.hasTypeSymbol) {
+        return undefined;
+      }
+
+      return this.type!.resolveMemberByName(name);
+    }
+    for (const space of this.memberSpaces) {
+      const member = space.symbolNames.get(name);
+      if (member) {
+        return member;
+      }
+    }
+
+    return undefined;
+  }
+
   // Tell \@vue/reactivity that this symbol should never be wrapped in a reactive
   // proxy.
   [ReactiveFlags.SKIP] = true;
@@ -502,6 +541,7 @@ export abstract class OutputSymbol {
     this.#isTransient = !!options.transient;
     this.#isTyped = !!options.type;
     this.type = options.type;
+    this.#lazyMemberInitializer = options.lazyMemberInitializer;
 
     this.#handleNewSpaces(this.#spaces);
     const constructor = this.constructor as typeof OutputSymbol;

package/src/tracer.ts

@@ -1,6 +1,6 @@
-import { effect, ReactiveEffectRunner } from "@vue/reactivity";
+import { effect } from "@vue/reactivity";
 import { untrack } from "./reactivity.js";
-import { isMemberRefkey, type Refkey } from "./refkey.js";
+import { inspectRefkey, type Refkey } from "./refkey.js";
 import { scheduler } from "./scheduler.js";
 import { type OutputScope } from "./symbols/output-scope.js";
 import type {
@@ -210,7 +210,7 @@ export function traceEffect(phase: TracePhase, cb: () => string) {
   let first = true;
   const triggerIds = new Set<number>();
 
-  const runner: ReactiveEffectRunner<void> = effect(
+  effect(
     () => {
       if (first) {
         // just track what we need, don't log.
@@ -222,7 +222,7 @@ export function traceEffect(phase: TracePhase, cb: () => string) {
       triggerIds.clear();
     },
     {
-      scheduler: scheduler(() => runner, true),
+      scheduler: scheduler(true),
       onTrigger(event) {
         const id = triggerCount++;
         if (dids.has(id)) {
@@ -429,10 +429,7 @@ export function formatRefkeys(refkeys: Refkey[] | Refkey | undefined) {
 }
 
 function formatRefkey(refkey: Refkey): string {
-  const text =
-    isMemberRefkey(refkey) ?
-      `memberRefkey[${formatRefkey(refkey.base)} -> ${formatRefkey(refkey.member)}]`
-    : `refkey[${refkey.key}]`;
+  const text = inspectRefkey(refkey);
 
   return colorText(text, {
     fg: {

package/src/utils.tsx

@@ -56,6 +56,22 @@ export function mapJoin<T, U, V>(
   cb: (key: T, value: U, index: number) => V,
   options?: JoinOptions,
 ): () => (V | string | undefined | CustomContext)[];
+/**
+ * Map a Map to an array using a mapper and place a joiner between each element.
+ * Defaults to joining with a newline.
+ *
+ * @see {@link join} for joining without mapping.
+ * @param src - Source map.
+ * @param cb - Mapper function.
+ * @param options - Join options.
+ * @returns The mapped and joined array.
+ *
+ */
+export function mapJoin<U, V>(
+  src: () => Set<U>,
+  cb: (value: U, index: number) => V,
+  options?: JoinOptions,
+): () => (V | string | undefined | CustomContext)[];
 /**
  * Map a array or iterator to another array using a mapper and place a joiner
  * between each element. Defaults to joining with a newline.
@@ -72,7 +88,7 @@ export function mapJoin<T, V>(
   options?: JoinOptions,
 ): () => (V | string | undefined | CustomContext)[];
 export function mapJoin<T, U, V>(
-  src: () => Map<T, U> | T[] | Iterable<T>,
+  src: () => Map<T, U> | Set<T> | T[] | Iterable<T>,
   cb: (key: T, valueOrIndex: U | number, index: number) => V,
   rawOptions: JoinOptions = {},
 ): () => Children {
@@ -94,6 +110,7 @@ export function mapJoin<T, U, V>(
     const itemsSourceRaw = toRaw(itemsSource);
     let items =
       Array.isArray(itemsSourceRaw) ? (itemsSource as T[]) : [...itemsSource];
+
     if (options.skipFalsy) {
       items = items.filter(
         (item) =>
@@ -103,8 +120,8 @@ export function mapJoin<T, U, V>(
     // this is important to access here in reactive context so we are
     // notified of new items from reactives.
     const itemsLen = items.length;
-    const compare: any = getCompareFunction(itemsSource);
-    const mapper: any = getMapperFunction(itemsSource);
+    const compare: any = getCompareFunction(itemsSourceRaw);
+    const mapper: any = getMapperFunction(itemsSourceRaw);
 
     return untrack(() => {
       let startIndex = 0;
@@ -160,7 +177,11 @@ export function mapJoin<T, U, V>(
   }
 
   function getMapperFunction(itemsSource: Map<T, U> | T[] | Iterable<T>) {
-    return Array.isArray(itemsSource) || isIterable(itemsSource) ?
+    return (
+        Array.isArray(itemsSource) ||
+          itemsSource instanceof Set ||
+          isIterable(itemsSource)
+      ) ?
         mapArray
       : mapMap;
   }