@alloy-js/core 0.16.0 → 0.18.0-dev.2

package/src/props-combinators.ts

@@ -0,0 +1,148 @@
+import { computed, isReactive, proxyRefs, toRefs } from "@vue/reactivity";
+import { untrack } from "./reactivity.js";
+
+export function mergeProps<T, U>(source: T, source1: U): T & U;
+export function mergeProps<T, U, V>(
+  source: T,
+  source1: U,
+  source2: V,
+): T & U & V;
+export function mergeProps<T, U, V, W>(
+  source: T,
+  source1: U,
+  source2: V,
+  source3: W,
+): T & U & V & W;
+export function mergeProps(...sources: any): any {
+  const target = {};
+  for (let i = 0; i < sources.length; i++) {
+    let source = sources[i];
+    if (typeof source === "function") source = source();
+    if (source) {
+      const descriptors = Object.getOwnPropertyDescriptors(source);
+      for (const key in descriptors) {
+        if (key in target) continue;
+        Object.defineProperty(target, key, {
+          enumerable: true,
+          get() {
+            for (let i = sources.length - 1; i >= 0; i--) {
+              let s = sources[i];
+              if (typeof s === "function") s = s();
+              const v = (s || {})[key];
+              if (v !== undefined) return v;
+            }
+          },
+        });
+      }
+    }
+  }
+  return target;
+}
+
+export type SplitProps<T, K extends (readonly (keyof T)[])[]> = [
+  ...{
+    [P in keyof K]: P extends `${number}` ?
+      Pick<T, Extract<K[P], readonly (keyof T)[]>[number]>
+    : never;
+  },
+  { [P in keyof T as Exclude<P, K[number][number]>]: T[P] },
+];
+
+export function splitProps<
+  T extends Record<any, any>,
+  K extends [readonly (keyof T)[], ...(readonly (keyof T)[])[]],
+>(props: T, ...keys: K): SplitProps<T, K> {
+  if (isReactive(props)) {
+    const refs = untrack(() => toRefs(props));
+    const remainingKeys = new Set(Object.keys(refs));
+
+    const result: any = keys.map((keySet) => {
+      const resultSet: any = {};
+      for (const key of keySet) {
+        resultSet[key] = refs[key];
+        remainingKeys.delete(key as string);
+      }
+      return proxyRefs(resultSet);
+    });
+
+    const remaining: any = {};
+    for (const key of remainingKeys) {
+      remaining[key] = refs[key];
+    }
+
+    return [...result, proxyRefs(remaining)] as any;
+  }
+
+  const descriptors = Object.getOwnPropertyDescriptors(props);
+  const remainingKeys = new Set(Object.keys(descriptors));
+  const result: any = keys.map((keySet) => {
+    const resultSet: any = {};
+    for (const key of keySet) {
+      if (key in descriptors) {
+        Object.defineProperty(resultSet, key, descriptors[key]);
+        remainingKeys.delete(key as string);
+      }
+    }
+    return resultSet;
+  });
+
+  const remaining: any = {};
+  for (const key of remainingKeys) {
+    Object.defineProperty(remaining, key, descriptors[key]);
+  }
+
+  return [...result, remaining] as any;
+}
+
+/**
+ * Applies default values to a props object. Reactive props are handled properly
+ * by ensuring that their value is not accessed by `defaultProps`, avoiding any
+ * unintended side effects.
+ */
+export function defaultProps<T extends {}>(props: T, defaults: Partial<T>): T {
+  if (isReactive(props)) {
+    const refs = untrack(() => toRefs(props));
+    for (const key in defaults) {
+      const originalRef = refs[key];
+      refs[key] = computed(() =>
+        originalRef.value === undefined ? defaults[key] : originalRef.value,
+      ) as any;
+    }
+
+    return proxyRefs(refs);
+  }
+  const withDefaults = {} as T;
+  const copied = new Set<string>();
+  for (const key in defaults) {
+    copied.add(key);
+    const desc = Object.getOwnPropertyDescriptor(props, key);
+    if (!desc) {
+      withDefaults[key] = defaults[key]!;
+      continue;
+    }
+
+    if (desc.get) {
+      const originalGet = desc.get;
+      desc.get = function () {
+        const value = originalGet.call(this);
+        return value === undefined ? defaults[key as keyof T] : value;
+      };
+      Object.defineProperty(withDefaults, key, desc);
+    } else {
+      desc.value =
+        desc.value === undefined ? defaults[key as keyof T] : desc.value;
+      Object.defineProperty(withDefaults, key, desc);
+    }
+  }
+
+  const descriptors = Object.getOwnPropertyDescriptors(props);
+  for (const key in descriptors) {
+    if (copied.has(key)) {
+      continue;
+    }
+
+    Object.defineProperty(withDefaults, key, descriptors[key]);
+  }
+
+  return withDefaults;
+}

package/src/reactive-union-set.ts

@@ -0,0 +1,238 @@
+import {
+  ITERATE_KEY,
+  ReactiveFlags,
+  shallowReactive,
+  shallowReadonly,
+  track,
+  TrackOpTypes,
+  trigger,
+  TriggerOpTypes,
+} from "@vue/reactivity";
+import { effect } from "./reactivity.js";
+
+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/reactivity.ts

@@ -0,0 +1,230 @@
+import {
+  pauseTracking,
+  ReactiveEffectRunner,
+  resetTracking,
+  ShallowReactive,
+  shallowRef,
+  stop,
+  effect as vueEffect,
+} from "@vue/reactivity";
+import type { RenderedTextTree } from "./render.js";
+import type { Children, ComponentCreator } from "./runtime/component.js";
+import { scheduler } from "./scheduler.js";
+import type { OutputSymbol } from "./symbols/output-symbol.js";
+import { trace, TracePhase } from "./tracer.js";
+
+// check for multiple versions of alloy here.
+if ((globalThis as any).__ALLOY__) {
+  throw new Error(
+    "Multiple versions of Alloy are loaded for this project. This will likely cause undesirable behavior.",
+  );
+}
+(globalThis as any).__ALLOY__ = true;
+
+export function getElementCache() {
+  return getContext()!.elementCache;
+}
+
+export type ElementCacheKey =
+  | ComponentCreator
+  | (() => unknown)
+  | CustomContext;
+
+export type ElementCache = Map<ElementCacheKey, RenderedTextTree>;
+
+export interface Disposable {
+  (): void;
+}
+
+export interface Context {
+  disposables: Disposable[];
+  owner: Context | null;
+
+  // context providers
+  context?: Record<symbol, unknown>;
+
+  // store random info about the node
+  meta?: Record<string, any>;
+
+  /**
+   * A cache of RenderTextTree nodes created within this context,
+   * indexed by the component or function which created them.
+   */
+  elementCache: ElementCache;
+  /**
+   * When this context was created by a component, this will
+   * 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;
+export function getContext() {
+  return globalContext;
+}
+
+export interface RootOptions {
+  componentOwner?: ComponentCreator<any>;
+}
+
+export function root<T>(fn: (d: Disposable) => T, options?: RootOptions): T {
+  const context: Context = {
+    componentOwner: options?.componentOwner,
+    disposables: [],
+    owner: globalContext,
+    context: {},
+    elementCache: new Map(),
+    takesSymbols: false,
+    takenSymbols: undefined,
+  };
+
+  globalContext = context;
+  let ret;
+  try {
+    ret = untrack(() =>
+      fn(() => {
+        for (const d of context!.disposables) {
+          d();
+        }
+      }),
+    );
+  } finally {
+    globalContext = globalContext!.owner;
+  }
+
+  return ret;
+}
+
+export function untrack<T>(fn: () => T): T {
+  pauseTracking();
+  const v = fn();
+  resetTracking();
+  return v;
+}
+
+export function memo<T>(fn: () => T, equal?: boolean): () => T {
+  const o = shallowRef();
+  effect((prev) => {
+    const res = fn();
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    (!equal || prev !== res) && (o.value = res);
+    return res;
+  }, undefined as T);
+  return () => o.value;
+}
+
+export function effect<T>(fn: (prev?: T) => T, current?: T) {
+  const context: Context = {
+    context: {},
+    disposables: [] as (() => void)[],
+    owner: globalContext,
+    elementCache: new Map(),
+    takesSymbols: false,
+    takenSymbols: undefined,
+  };
+
+  const cleanupFn = (final: boolean) => {
+    const d = context.disposables;
+    context.disposables = [];
+    for (let k = 0, len = d.length; k < len; k++) d[k]();
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    final && stop(runner);
+  };
+
+  onCleanup(() => cleanupFn(true));
+  const runner: ReactiveEffectRunner<void> = vueEffect(
+    () => {
+      cleanupFn(false);
+
+      const oldContext = globalContext;
+      globalContext = context;
+      try {
+        current = fn(current);
+      } finally {
+        globalContext = oldContext;
+      }
+    },
+    {
+      scheduler: scheduler(() => runner),
+      onTrack(event) {
+        trace(TracePhase.effect.track, () => {
+          return `tracking ${event.target}, ${event.key}`;
+        });
+      },
+      onTrigger(event) {
+        trace(TracePhase.effect.trigger, () => {
+          return `triggering ${event.target}, ${event.key}`;
+        });
+      },
+    },
+  );
+
+  // allow recursive effects (recursive option does nothing, possible bug)
+  (runner as any).effect.flags |= 1 << 5;
+}
+
+/**
+ * Register a cleanup function which is called when the current reactive scope
+ * is recalculated or disposed. This is useful to clean up any side effects
+ * created in the reactive scope.
+ *
+ * @remarks
+ *
+ * When onCleanup is called inside a component definition, the provided function
+ * is called when the component is removed from the tree. This can be useful to
+ * clean up any side effects created as a result of rendering the component. For
+ * example, if rendering a component creates a symbol, `onCleanup` can be used
+ * to remove the symbol when the component is removed from the tree.
+ *
+ * When onCleanup is called inside a memo or effect, the function is called when
+ * the effect is refreshed (e.g. when a memo or computed recalculates) or
+ * disposed (e.g. it is no longer needed because it is attached to a component
+ * which was removed).
+ */
+export function onCleanup(fn: Disposable) {
+  if (globalContext != null) {
+    globalContext.disposables.push(fn);
+  }
+}
+
+/**
+ * Create a custom reactive context for the children returned by
+ * the provided context.
+ */
+export interface CustomContext {
+  [CUSTOM_CONTEXT_SYM]: true;
+  useCustomContext: (useCb: CustomContextChildrenCallback) => void;
+}
+
+export type CustomContextChildrenCallback = (child: Children) => void;
+const CUSTOM_CONTEXT_SYM = Symbol();
+
+export function createCustomContext(
+  useCallback: (useChildren: CustomContextChildrenCallback) => void,
+): CustomContext {
+  return {
+    [CUSTOM_CONTEXT_SYM]: true,
+    useCustomContext(useCb: (children: Children) => void): void {
+      useCallback(useCb);
+    },
+  };
+}
+
+export function isCustomContext(child: Children): child is CustomContext {
+  return (
+    typeof child === "object" &&
+    child !== null &&
+    Object.hasOwn(child, CUSTOM_CONTEXT_SYM)
+  );
+}

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);
+}