@alloy-js/core 0.15.0 → 0.17.0

package/src/components/Block.tsx

@@ -1,4 +1,7 @@
-import { Children, childrenArray, computed, Indent } from "@alloy-js/core";
+import { computed } from "@vue/reactivity";
+import { Children } from "../jsx-runtime.js";
+import { childrenArray } from "../utils.jsx";
+import { Indent } from "./Indent.jsx";
 
 export interface BlockProps {
   /**

package/src/components/Declaration.tsx

@@ -1,9 +1,9 @@
-import { OutputSymbol } from "../binder.js";
 import { useContext } from "../context.js";
 import { BinderContext } from "../context/binder.js";
 import { DeclarationContext } from "../context/declaration.js";
 import { Children, onCleanup } from "../jsx-runtime.js";
 import { Refkey } from "../refkey.js";
+import { OutputSymbol } from "../symbols/output-symbol.js";
 
 /**
  * Create a declaration by providing an already created symbol. The symbol is
@@ -68,18 +68,18 @@ export function Declaration(props: DeclarationProps) {
     throw new Error("Need binder context to create declarations");
   }
 
-  let declaration;
+  let declaration: OutputSymbol;
   if ("symbol" in props) {
     declaration = props.symbol;
   } else {
-    declaration = binder.createSymbol({
-      name: props.name!,
-      refkey: props.refkey,
+    declaration = new OutputSymbol(props.name, {
+      binder,
+      refkeys: [props.refkey ?? []].flat(),
       metadata: props.metadata,
     });
 
     onCleanup(() => {
-      binder.deleteSymbol(declaration!);
+      declaration.delete();
     });
   }
 

package/src/components/For.tsx

@@ -1,5 +1,5 @@
-import { Children, memo } from "@alloy-js/core/jsx-runtime";
 import { isRef, Ref } from "@vue/reactivity";
+import { type Children, memo } from "../jsx-runtime.js";
 import { baseListPropsToMapJoinArgs, mapJoin } from "../utils.js";
 import { BaseListProps } from "./List.jsx";
 

package/src/components/Indent.tsx

@@ -1,4 +1,4 @@
-import { Children } from "@alloy-js/core/jsx-runtime";
+import type { Children } from "../jsx-runtime.js";
 
 export interface IndentProps {
   children: Children;

package/src/components/List.tsx

@@ -1,4 +1,4 @@
-import { Children, memo, splitProps } from "@alloy-js/core/jsx-runtime";
+import { Children, memo, splitProps } from "../jsx-runtime.js";
 import { childrenArray } from "../utils.js";
 import { For } from "./For.jsx";
 

package/src/components/MemberDeclaration.tsx

@@ -1,9 +1,9 @@
-import { OutputSymbol, OutputSymbolFlags } from "../binder.js";
 import { useContext } from "../context.js";
 import { BinderContext } from "../context/binder.js";
 import { MemberDeclarationContext } from "../context/member-declaration.js";
 import { Children } from "../jsx-runtime.js";
 import { Refkey } from "../refkey.js";
+import { OutputSymbol, OutputSymbolFlags } from "../symbols/output-symbol.js";
 
 /**
  * Create a member declaration by providing a symbol name and optional symbol
@@ -85,9 +85,9 @@ export function MemberDeclaration(props: MemberDeclarationProps) {
         "Must provide a member name, or else provide a member symbol",
       );
     }
-    declaration = binder.createSymbol({
-      name: infoProps.name!,
-      refkey: infoProps.refkey,
+
+    declaration = new OutputSymbol(infoProps.name!, {
+      refkeys: infoProps.refkey,
       metadata: infoProps.metadata,
       flags:
         infoProps.static ?

package/src/components/MemberScope.tsx

@@ -1,9 +1,6 @@
-import { OutputSymbol } from "../binder.js";
-import { Children } from "../jsx-runtime.js";
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { OutputSymbolFlags } from "../binder.js";
 import { MemberScopeContext } from "../context/member-scope.js";
+import { Children } from "../jsx-runtime.js";
+import { OutputSymbol } from "../symbols/output-symbol.js";
 export interface MemberScopeProps {
   /**
    * The name of the member scope.

package/src/components/Prose.tsx

@@ -1,5 +1,5 @@
 import { childrenArray, computed } from "@alloy-js/core";
-import { Children } from "@alloy-js/core/jsx-runtime";
+import type { Children } from "../jsx-runtime.js";
 
 export interface Prose {
   children: Children;

package/src/components/ReferenceOrContent.tsx

@@ -1,7 +1,7 @@
-import { Children } from "@alloy-js/core/jsx-runtime";
 import { computed } from "@vue/reactivity";
 import { useContext } from "../context.js";
 import { BinderContext } from "../context/binder.js";
+import type { Children } from "../jsx-runtime.js";
 import type { Refkey } from "../refkey.js";
 
 export interface ReferenceOrContentProps {

package/src/components/Scope.tsx

@@ -1,8 +1,6 @@
-import { OutputScope } from "../binder.js";
-import { useContext } from "../context.js";
-import { BinderContext } from "../context/binder.js";
 import { ScopeContext } from "../context/scope.js";
 import { Children } from "../jsx-runtime.js";
+import { OutputScope } from "../symbols/output-scope.js";
 
 /**
  * Declare a scope by providing an already created scope. The scope is merely
@@ -53,11 +51,9 @@ export function Scope(props: ScopeProps) {
   if ("value" in props) {
     scope = props.value;
   } else {
-    const binder = useContext(BinderContext)!;
-    scope = binder.createScope({
+    scope = new OutputScope(props.name ?? "", {
       kind: props.kind,
       metadata: props.metadata,
-      name: props.name ?? "",
     });
   }
 

package/src/components/Show.tsx

@@ -1,4 +1,4 @@
-import { Children } from "@alloy-js/core/jsx-runtime";
+import type { Children } from "../jsx-runtime.js";
 
 export interface ShowProps {
   children: Children;

package/src/components/StatementList.tsx

@@ -1,4 +1,5 @@
-import { Children, List } from "@alloy-js/core";
+import type { Children } from "../jsx-runtime.js";
+import { List } from "./List.jsx";
 
 export interface StatementListProps {
   children: Children;

package/src/components/Switch.tsx

@@ -1,4 +1,4 @@
-import { Children, memo, taggedComponent } from "@alloy-js/core/jsx-runtime";
+import { type Children, memo, taggedComponent } from "../jsx-runtime.js";
 import { childrenArray, findKeyedChildren } from "../utils.js";
 
 export interface SwitchProps {

package/src/components/Wrap.tsx

@@ -1,4 +1,4 @@
-import { Children, ComponentDefinition } from "@alloy-js/core/jsx-runtime";
+import { Children, ComponentDefinition } from "../jsx-runtime.js";
 
 export interface WrapProps<TProps> {
   /**

package/src/context/assignment.ts

@@ -1,9 +1,9 @@
-import { OutputSymbol } from "../binder.js";
 import {
   ComponentContext,
   createNamedContext,
   useContext,
 } from "../context.js";
+import type { OutputSymbol } from "../symbols/output-symbol.js";
 
 export interface AssignmentContext {
   /**

package/src/context/binder.ts

@@ -1,4 +1,4 @@
-import { Binder } from "../binder.js";
+import type { Binder } from "../binder.js";
 import {
   ComponentContext,
   createNamedContext,
@@ -15,5 +15,5 @@ export const BinderContext: ComponentContext<Binder> =
   createNamedContext("Binder");
 
 export function useBinder() {
-  return useContext(BinderContext)!;
+  return useContext(BinderContext);
 }

package/src/context/declaration.ts

@@ -1,5 +1,5 @@
-import { OutputSymbol } from "../binder.js";
 import { ComponentContext, createNamedContext } from "../context.js";
+import type { OutputSymbol } from "../symbols/output-symbol.js";
 
 export const DeclarationContext: ComponentContext<OutputSymbol> =
   createNamedContext("Declaration");

package/src/context/member-declaration.ts

@@ -1,9 +1,9 @@
-import { OutputSymbol } from "../binder.js";
 import {
   ComponentContext,
   createNamedContext,
   useContext,
 } from "../context.js";
+import type { OutputSymbol } from "../symbols/output-symbol.js";
 
 /**
  * Provides the symbol for the member currently being declared.

package/src/context/member-scope.ts

@@ -1,9 +1,9 @@
-import { OutputScope } from "../binder.js";
 import {
   ComponentContext,
   createNamedContext,
   useContext,
 } from "../context.js";
+import type { OutputScope } from "../symbols/output-scope.js";
 
 /**
  * The member scope context provides the instance and static member scopes that

package/src/context/name-policy.ts

@@ -3,7 +3,7 @@ import {
   createNamedContext,
   useContext,
 } from "../context.js";
-import { NamePolicy } from "../name-policy.js";
+import type { NamePolicy } from "../name-policy.js";
 
 export const NamePolicyContext: ComponentContext<NamePolicy<string>> =
   createNamedContext<NamePolicy<string>>("NamePolicy", {

package/src/context/scope.ts

@@ -1,9 +1,9 @@
-import { OutputScope } from "../binder.js";
 import {
   ComponentContext,
   createNamedContext,
   useContext,
 } from "../context.js";
+import type { OutputScope } from "../symbols/output-scope.js";
 
 export const ScopeContext: ComponentContext<OutputScope> =
   createNamedContext("Scope");

package/src/context/source-directory.ts

@@ -1,5 +1,5 @@
 import { ComponentContext, createNamedContext } from "../context.js";
-import { SourceFileContext } from "./source-file.js";
+import type { SourceFileContext } from "./source-file.js";
 
 export interface SourceDirectoryContext {
   contents: (SourceDirectoryContext | SourceFileContext)[];

package/src/context/source-file.ts

@@ -1,6 +1,6 @@
 import { ComponentContext, createNamedContext } from "../context.js";
-import { ComponentDefinition } from "../jsx-runtime.js";
-import { Refkey } from "../refkey.js";
+import type { ComponentDefinition } from "../jsx-runtime.js";
+import type { Refkey } from "../refkey.js";
 
 export interface SourceFileContext {
   path: string;

package/src/index.ts

@@ -1,6 +1,10 @@
 export {
+  TrackOpTypes,
+  TriggerOpTypes,
   computed,
   isProxy,
+  isReactive,
+  isRef,
   reactive,
   ref,
   shallowReactive,
@@ -8,7 +12,15 @@ export {
   toRaw,
   toRef,
   toRefs,
+  track,
+  trigger,
+  watch,
+  type Reactive,
   type Ref,
+  type ShallowReactive,
+  type ShallowRef,
+  type ToRef,
+  type ToRefs,
 } from "@vue/reactivity";
 export * from "./binder.js";
 export * from "./code.js";
@@ -17,10 +29,13 @@ export * from "./context.js";
 export * from "./context/index.js";
 export * from "./jsx-runtime.js";
 export * from "./name-policy.js";
+export * from "./reactive-union-set.js";
 export * from "./refkey.js";
 export * from "./render.js";
 export * from "./stc.js";
 export * from "./sti.js";
+export * from "./symbols/index.js";
+export * from "./symbols/symbol-flow.js";
 export * from "./tap.js";
 export * from "./utils.js";
 export * from "./write-output.js";

package/src/jsx-runtime.ts

@@ -8,14 +8,16 @@ import {
   ReactiveEffectRunner,
   Ref,
   resetTracking,
+  ShallowReactive,
   shallowRef,
   stop,
   toRefs,
   effect as vueEffect,
 } from "@vue/reactivity";
-import { Refkey } from "./refkey.js";
-import { RenderedTextTree } from "./render.js";
+import type { Refkey } from "./refkey.js";
+import type { RenderedTextTree } from "./render.js";
 import { scheduler } from "./scheduler.js";
+import type { OutputSymbol } from "./symbols/output-symbol.js";
 
 if ((globalThis as any).ALLOY) {
   throw new Error(
@@ -48,6 +50,16 @@ export interface Context {
    * be the component that created it.
    */
   componentOwner?: ComponentCreator<unknown>;
+
+  /**
+   * Whether this context will take an emitted symbol.
+   */
+  takesSymbols: boolean;
+
+  /**
+   * The symbol that this component has taken.
+   */
+  takenSymbols?: ShallowReactive<Set<OutputSymbol>>;
 }
 
 let globalContext: Context | null = null;
@@ -76,6 +88,8 @@ export function root<T>(fn: (d: Disposable) => T, options?: RootOptions): T {
     owner: globalContext,
     context: {},
     elementCache: new Map(),
+    takesSymbols: false,
+    takenSymbols: undefined,
   };
 
   globalContext = context;
@@ -119,6 +133,8 @@ export function effect<T>(fn: (prev?: T) => T, current?: T) {
     disposables: [] as (() => void)[],
     owner: globalContext,
     elementCache: new Map(),
+    takesSymbols: false,
+    takenSymbols: undefined,
   };
 
   const cleanupFn = (final: boolean) => {

package/src/reactive-union-set.ts

@@ -0,0 +1,238 @@
+import { effect } from "@alloy-js/core/jsx-runtime";
+import {
+  ITERATE_KEY,
+  ReactiveFlags,
+  shallowReactive,
+  shallowReadonly,
+  track,
+  TrackOpTypes,
+  trigger,
+  TriggerOpTypes,
+} from "@vue/reactivity";
+
+export interface ReactiveUnionSetOptions<T> {
+  onAdd?: OnReactiveSetAddCallback<T>;
+  onDelete?: OnReactiveSetDeleteCallback<T>;
+}
+
+export type OnReactiveSetDeleteCallback<T> = (value: T) => void;
+export type OnReactiveSetAddCallback<T> = (value: T) => T;
+
+export class ReactiveUnionSet<T> extends Set<T> {
+  private _subsets: Set<Set<T>>;
+  private _onAdd?: OnReactiveSetAddCallback<T>;
+  private _onDelete?: OnReactiveSetDeleteCallback<T>;
+  private _refcounts: Map<T, number> = new Map();
+  private _indexes: { add: (arg: T) => void; delete: (arg: T) => void }[] = [];
+
+  [ReactiveFlags.IS_REACTIVE] = true;
+
+  private _handleAdd(value: T) {
+    value = this._onAdd ? this._onAdd(value) : value;
+
+    for (const index of this._indexes) {
+      index.add(value);
+    }
+
+    return value;
+  }
+
+  private _handleDelete(value: T) {
+    if (this._onDelete) {
+      this._onDelete(value);
+    }
+
+    for (const index of this._indexes) {
+      index.delete(value);
+    }
+
+    return value;
+  }
+
+  constructor(options: ReactiveUnionSetOptions<T> = {}) {
+    super();
+
+    this._subsets = new Set();
+    this._onAdd = options.onAdd;
+    this._onDelete = options.onDelete;
+
+    return this;
+  }
+
+  get size() {
+    track(this, TrackOpTypes.ITERATE, ITERATE_KEY);
+    return super.size;
+  }
+
+  [Symbol.iterator](): SetIterator<T> {
+    track(this, TrackOpTypes.ITERATE, ITERATE_KEY);
+    return super[Symbol.iterator]();
+  }
+
+  keys(): SetIterator<T> {
+    track(this, TrackOpTypes.ITERATE, ITERATE_KEY);
+    return super.keys();
+  }
+
+  values(): SetIterator<T> {
+    track(this, TrackOpTypes.ITERATE, ITERATE_KEY);
+    return super.values();
+  }
+
+  entries(): SetIterator<[T, T]> {
+    track(this, TrackOpTypes.ITERATE, ITERATE_KEY);
+    return super.entries();
+  }
+
+  add(item: T) {
+    if (this._refcounts.has(item)) {
+      this._refcounts.set(item, this._refcounts.get(item)! + 1);
+    } else {
+      this._refcounts.set(item, 1);
+      super.add(item);
+      this._handleAdd(item);
+      trigger(this, TriggerOpTypes.ADD, item, item);
+    }
+
+    return this;
+  }
+
+  delete(item: T) {
+    const count = this._refcounts.get(item);
+    if (count === undefined) {
+      return false;
+    }
+
+    if (count > 1) {
+      this._refcounts.set(item, count - 1);
+    } else {
+      this._refcounts.delete(item);
+      super.delete(item);
+      this._handleDelete(item);
+      trigger(this, TriggerOpTypes.DELETE, undefined, item);
+    }
+
+    return true;
+  }
+
+  addSubset(subset: Set<T>, options: ReactiveUnionSetOptions<T> = {}) {
+    if (this._subsets.has(subset)) {
+      return;
+    }
+
+    const { onAdd, onDelete } = options;
+
+    this._subsets.add(subset);
+
+    /**
+     * Contains a map of the previous values and their mapped values
+     * that were added to the parent set.
+     */
+    const prevValues = new Map<T, T>();
+
+    effect(() => {
+      for (const [prevSourceValue, prevTargetValue] of prevValues) {
+        if (!subset.has(prevSourceValue)) {
+          onDelete?.(prevSourceValue);
+          prevValues.delete(prevSourceValue);
+          this.delete(prevTargetValue);
+        }
+      }
+
+      for (const value of subset) {
+        if (!prevValues.has(value)) {
+          if (onAdd) {
+            const added = onAdd(value);
+            prevValues.set(value, added);
+          } else {
+            this.add(value);
+            prevValues.set(value, value);
+          }
+        }
+      }
+    });
+  }
+
+  createDerivedSet<U>(mapper: (value: T) => U | U[]) {
+    const set = shallowReactive(new Set<U>());
+    const refcounts = new Map<U, number>();
+
+    function ref(value: U) {
+      if (refcounts.has(value)) {
+        const count = refcounts.get(value)! + 1;
+        refcounts.set(value, count);
+        return count;
+      } else {
+        refcounts.set(value, 1);
+        set.add(value);
+        return 1;
+      }
+    }
+
+    function unref(value: U) {
+      const count = refcounts.get(value)!;
+
+      if (count > 1) {
+        refcounts.set(value, count - 1);
+        return count - 1;
+      } else {
+        refcounts.delete(value);
+        set.delete(value);
+        return 0;
+      }
+    }
+
+    this._indexes.push({
+      add: (value: T) => {
+        effect((prev: U[] | U | undefined) => {
+          for (const id of [prev].flat()) {
+            unref(id as any);
+          }
+
+          const mappedValue = mapper(value);
+          for (const id of [mappedValue].flat()) {
+            ref(id as any);
+          }
+
+          return mappedValue;
+        });
+      },
+      delete: (value: T) => {
+        const mappedValue = mapper(value);
+        for (const id of [mappedValue].flat()) {
+          unref(id as any);
+        }
+      },
+    });
+
+    return shallowReadonly(set);
+  }
+  createIndex<U>(mapper: (value: T) => U | U[]): ReadonlyMap<U, T> {
+    const index = shallowReactive(new Map<U, T>());
+    this._indexes.push({
+      add: (value: T) => {
+        effect((oldValue) => {
+          for (const id of [oldValue].flat()) {
+            index.delete(id as U);
+          }
+
+          const mappedValue = mapper(value);
+
+          for (const id of [mappedValue].flat()) {
+            index.set(id as U, value as any);
+          }
+
+          return mappedValue;
+        });
+      },
+      delete: (value: T) => {
+        const mappedValue = mapper(value);
+        for (const id of [mappedValue].flat()) {
+          index.delete(id as U);
+        }
+      },
+    });
+
+    return shallowReadonly(index);
+  }
+}

package/src/refkey.ts

@@ -48,6 +48,20 @@ function getKey(value: unknown): Refkey {
 }
 
 const knownRefkeys = new Map<string, Refkey>();
+
+/**
+ * Create a refkey for the provided arguments. Passing no arguments returns a
+ * fresh refkey that is guaranteed to be unique. Otherwise, the arguments passed
+ * will be used to create a refkey for those values. Providing the same
+ * arguments will always return the same refkey.
+ *
+ * @remarks
+ *
+ * Values are compared using the SameValueZero algorithm, which considers
+ * objects the same if they are reference identical, and primitives the same if
+ * they are the same value, with the exception of `NaN`, which is always considered
+ * equal to other `NaN` values, and `-0`, which is considered identical to `+0`
+ */
 export function refkey(...args: unknown[]): Refkey {
   const keys = args.length === 0 ? [getKey({})] : args.map((v) => getKey(v));
 
@@ -60,3 +74,29 @@ export function refkey(...args: unknown[]): Refkey {
   knownRefkeys.set(compositeKey, key);
   return key;
 }
+
+/**
+ * Create a refkey for an instantiation of a symbol.
+ *
+ * @param base - The refkey of the symbol holding the instantiation.
+ * @param member - The refkey of the non-instantiated member symbol (either the
+ * instance or static member symbol)
+ *
+ * @remarks
+ *
+ * Refkeys for instantiated and copied members are a composite refkey of the
+ * owner's refkey and the member's refkey. So for example, given a refkey for an
+ * instantiation of a class `rk1`, and a refkey for the instance member of that
+ * class `rk2`, the refkey for the instantiated static member is
+ * `refkey(rk1, rk2)`. This function will return the same refkey given those
+ * same parameters.
+ *
+ * When a static member symbol `rk3` is owned by another static or instance
+ * member symbol (i.e. the outer symbol is itself a member container), the
+ * refkey of the instaniated static member is still just the composite of the
+ * instantiated variable refkey and the refkey of the inner member
+ * `refkey(rk1, rk3)`.
+ */
+export function memberRefkey(base: Refkey, member: Refkey): Refkey {
+  return refkey(base, member);
+}