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

package/dist/src/props-combinators.js

@@ -0,0 +1,108 @@
+import { computed, isReactive, proxyRefs, toRefs } from "@vue/reactivity";
+import { untrack } from "./reactivity.js";
+export function mergeProps(...sources) {
+  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 function splitProps(props, ...keys) {
+  if (isReactive(props)) {
+    const refs = untrack(() => toRefs(props));
+    const remainingKeys = new Set(Object.keys(refs));
+    const result = keys.map(keySet => {
+      const resultSet = {};
+      for (const key of keySet) {
+        resultSet[key] = refs[key];
+        remainingKeys.delete(key);
+      }
+      return proxyRefs(resultSet);
+    });
+    const remaining = {};
+    for (const key of remainingKeys) {
+      remaining[key] = refs[key];
+    }
+    return [...result, proxyRefs(remaining)];
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(props);
+  const remainingKeys = new Set(Object.keys(descriptors));
+  const result = keys.map(keySet => {
+    const resultSet = {};
+    for (const key of keySet) {
+      if (key in descriptors) {
+        Object.defineProperty(resultSet, key, descriptors[key]);
+        remainingKeys.delete(key);
+      }
+    }
+    return resultSet;
+  });
+  const remaining = {};
+  for (const key of remainingKeys) {
+    Object.defineProperty(remaining, key, descriptors[key]);
+  }
+  return [...result, remaining];
+}
+
+/**
+ * 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(props, defaults) {
+  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);
+    }
+    return proxyRefs(refs);
+  }
+  const withDefaults = {};
+  const copied = new Set();
+  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] : value;
+      };
+      Object.defineProperty(withDefaults, key, desc);
+    } else {
+      desc.value = desc.value === undefined ? defaults[key] : 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/dist/src/reactive-union-set.d.ts

@@ -0,0 +1,29 @@
+import { ReactiveFlags } 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 declare class ReactiveUnionSet<T> extends Set<T> {
+    private _subsets;
+    private _onAdd?;
+    private _onDelete?;
+    private _refcounts;
+    private _indexes;
+    [ReactiveFlags.IS_REACTIVE]: boolean;
+    private _handleAdd;
+    private _handleDelete;
+    constructor(options?: ReactiveUnionSetOptions<T>);
+    get size(): number;
+    [Symbol.iterator](): SetIterator<T>;
+    keys(): SetIterator<T>;
+    values(): SetIterator<T>;
+    entries(): SetIterator<[T, T]>;
+    add(item: T): this;
+    delete(item: T): boolean;
+    addSubset(subset: Set<T>, options?: ReactiveUnionSetOptions<T>): void;
+    createDerivedSet<U>(mapper: (value: T) => U | U[]): Readonly<import("@vue/reactivity").ShallowReactive<Set<U>>>;
+    createIndex<U>(mapper: (value: T) => U | U[]): ReadonlyMap<U, T>;
+}
+//# sourceMappingURL=reactive-union-set.d.ts.map

package/dist/src/reactive-union-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive-union-set.d.ts","sourceRoot":"","sources":["../../src/reactive-union-set.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EAOd,MAAM,iBAAiB,CAAC;AAGzB,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,KAAK,CAAC,EAAE,wBAAwB,CAAC,CAAC,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,2BAA2B,CAAC,CAAC,CAAC,CAAC;CAC3C;AAED,MAAM,MAAM,2BAA2B,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAChE,MAAM,MAAM,wBAAwB,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;AAE1D,qBAAa,gBAAgB,CAAC,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,CAAC;IAC7C,OAAO,CAAC,QAAQ,CAAc;IAC9B,OAAO,CAAC,MAAM,CAAC,CAA8B;IAC7C,OAAO,CAAC,SAAS,CAAC,CAAiC;IACnD,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,QAAQ,CAA6D;IAE7E,CAAC,aAAa,CAAC,WAAW,CAAC,UAAQ;IAEnC,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,aAAa;gBAYT,OAAO,GAAE,uBAAuB,CAAC,CAAC,CAAM;IAUpD,IAAI,IAAI,WAGP;IAED,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC;IAKnC,IAAI,IAAI,WAAW,CAAC,CAAC,CAAC;IAKtB,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC;IAKxB,OAAO,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAK9B,GAAG,CAAC,IAAI,EAAE,CAAC;IAaX,MAAM,CAAC,IAAI,EAAE,CAAC;IAkBd,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,uBAAuB,CAAC,CAAC,CAAM;IAsClE,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;IAsDjD,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC;CA4BjE"}

package/dist/src/reactive-union-set.js

@@ -0,0 +1,183 @@
+import { ITERATE_KEY, ReactiveFlags, shallowReactive, shallowReadonly, track, TrackOpTypes, trigger, TriggerOpTypes } from "@vue/reactivity";
+import { effect } from "./reactivity.js";
+export class ReactiveUnionSet extends Set {
+  _refcounts = new Map();
+  _indexes = [];
+  [ReactiveFlags.IS_REACTIVE] = true;
+  _handleAdd(value) {
+    value = this._onAdd ? this._onAdd(value) : value;
+    for (const index of this._indexes) {
+      index.add(value);
+    }
+    return value;
+  }
+  _handleDelete(value) {
+    if (this._onDelete) {
+      this._onDelete(value);
+    }
+    for (const index of this._indexes) {
+      index.delete(value);
+    }
+    return value;
+  }
+  constructor(options = {}) {
+    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]() {
+    track(this, TrackOpTypes.ITERATE, ITERATE_KEY);
+    return super[Symbol.iterator]();
+  }
+  keys() {
+    track(this, TrackOpTypes.ITERATE, ITERATE_KEY);
+    return super.keys();
+  }
+  values() {
+    track(this, TrackOpTypes.ITERATE, ITERATE_KEY);
+    return super.values();
+  }
+  entries() {
+    track(this, TrackOpTypes.ITERATE, ITERATE_KEY);
+    return super.entries();
+  }
+  add(item) {
+    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) {
+    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, options = {}) {
+    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();
+    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(mapper) {
+    const set = shallowReactive(new Set());
+    const refcounts = new Map();
+    function ref(value) {
+      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) {
+      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 => {
+        effect(prev => {
+          for (const id of [prev].flat()) {
+            unref(id);
+          }
+          const mappedValue = mapper(value);
+          for (const id of [mappedValue].flat()) {
+            ref(id);
+          }
+          return mappedValue;
+        });
+      },
+      delete: value => {
+        const mappedValue = mapper(value);
+        for (const id of [mappedValue].flat()) {
+          unref(id);
+        }
+      }
+    });
+    return shallowReadonly(set);
+  }
+  createIndex(mapper) {
+    const index = shallowReactive(new Map());
+    this._indexes.push({
+      add: value => {
+        effect(oldValue => {
+          for (const id of [oldValue].flat()) {
+            index.delete(id);
+          }
+          const mappedValue = mapper(value);
+          for (const id of [mappedValue].flat()) {
+            index.set(id, value);
+          }
+          return mappedValue;
+        });
+      },
+      delete: value => {
+        const mappedValue = mapper(value);
+        for (const id of [mappedValue].flat()) {
+          index.delete(id);
+        }
+      }
+    });
+    return shallowReadonly(index);
+  }
+}

package/dist/src/reactivity.d.ts

@@ -0,0 +1,75 @@
+import { ShallowReactive } from "@vue/reactivity";
+import type { RenderedTextTree } from "./render.js";
+import type { Children, ComponentCreator } from "./runtime/component.js";
+import type { OutputSymbol } from "./symbols/output-symbol.js";
+export declare function getElementCache(): 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?: Record<symbol, unknown>;
+    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>>;
+}
+export declare function getContext(): Context | null;
+export interface RootOptions {
+    componentOwner?: ComponentCreator<any>;
+}
+export declare function root<T>(fn: (d: Disposable) => T, options?: RootOptions): T;
+export declare function untrack<T>(fn: () => T): T;
+export declare function memo<T>(fn: () => T, equal?: boolean): () => T;
+export declare function effect<T>(fn: (prev?: T) => T, current?: T): void;
+/**
+ * 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 declare function onCleanup(fn: Disposable): void;
+/**
+ * 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;
+declare const CUSTOM_CONTEXT_SYM: unique symbol;
+export declare function createCustomContext(useCallback: (useChildren: CustomContextChildrenCallback) => void): CustomContext;
+export declare function isCustomContext(child: Children): child is CustomContext;
+export {};
+//# sourceMappingURL=reactivity.d.ts.map

package/dist/src/reactivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactivity.d.ts","sourceRoot":"","sources":["../../src/reactivity.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,eAAe,EAIhB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAEzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAW/D,wBAAgB,eAAe,iBAE9B;AAED,MAAM,MAAM,eAAe,GACvB,gBAAgB,GAChB,CAAC,MAAM,OAAO,CAAC,GACf,aAAa,CAAC;AAElB,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,eAAe,EAAE,gBAAgB,CAAC,CAAC;AAElE,MAAM,WAAW,UAAU;IACzB,IAAI,IAAI,CAAC;CACV;AAED,MAAM,WAAW,OAAO;IACtB,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAGtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAGlC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE3B;;;OAGG;IACH,YAAY,EAAE,YAAY,CAAC;IAC3B;;;OAGG;IACH,cAAc,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAE3C;;OAEG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB;;OAEG;IACH,YAAY,CAAC,EAAE,eAAe,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC;CACnD;AAGD,wBAAgB,UAAU,mBAEzB;AAED,MAAM,WAAW,WAAW;IAC1B,cAAc,CAAC,EAAE,gBAAgB,CAAC,GAAG,CAAC,CAAC;CACxC;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,CAAC,CA0B1E;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAKzC;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC,CAS7D;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,QAiDzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,UAAU,QAIvC;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,CAAC,kBAAkB,CAAC,EAAE,IAAI,CAAC;IAC3B,gBAAgB,EAAE,CAAC,KAAK,EAAE,6BAA6B,KAAK,IAAI,CAAC;CAClE;AAED,MAAM,MAAM,6BAA6B,GAAG,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAC;AACtE,QAAA,MAAM,kBAAkB,eAAW,CAAC;AAEpC,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,CAAC,WAAW,EAAE,6BAA6B,KAAK,IAAI,GAChE,aAAa,CAOf;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,KAAK,IAAI,aAAa,CAMvE"}

package/dist/src/reactivity.js

@@ -0,0 +1,141 @@
+import { pauseTracking, resetTracking, shallowRef, stop, effect as vueEffect } from "@vue/reactivity";
+import { scheduler } from "./scheduler.js";
+import { trace, TracePhase } from "./tracer.js";
+
+// check for multiple versions of alloy here.
+if (globalThis.__ALLOY__) {
+  throw new Error("Multiple versions of Alloy are loaded for this project. This will likely cause undesirable behavior.");
+}
+globalThis.__ALLOY__ = true;
+export function getElementCache() {
+  return getContext().elementCache;
+}
+let globalContext = null;
+export function getContext() {
+  return globalContext;
+}
+export function root(fn, options) {
+  const 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(fn) {
+  pauseTracking();
+  const v = fn();
+  resetTracking();
+  return v;
+}
+export function memo(fn, equal) {
+  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);
+  return () => o.value;
+}
+export function effect(fn, current) {
+  const context = {
+    context: {},
+    disposables: [],
+    owner: globalContext,
+    elementCache: new Map(),
+    takesSymbols: false,
+    takenSymbols: undefined
+  };
+  const cleanupFn = final => {
+    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 = 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.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) {
+  if (globalContext != null) {
+    globalContext.disposables.push(fn);
+  }
+}
+
+/**
+ * Create a custom reactive context for the children returned by
+ * the provided context.
+ */
+
+const CUSTOM_CONTEXT_SYM = Symbol();
+export function createCustomContext(useCallback) {
+  return {
+    [CUSTOM_CONTEXT_SYM]: true,
+    useCustomContext(useCb) {
+      useCallback(useCb);
+    }
+  };
+}
+export function isCustomContext(child) {
+  return typeof child === "object" && child !== null && Object.hasOwn(child, CUSTOM_CONTEXT_SYM);
+}

package/dist/src/refkey.d.ts

@@ -4,6 +4,42 @@ export type Refkey = {
     [RefkeySym]: true;
 };
 export declare function isRefkey(value: unknown): value is 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 declare function refkey(...args: unknown[]): Refkey;
+/**
+ * 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 declare function memberRefkey(base: Refkey, member: Refkey): Refkey;
 export {};
 //# sourceMappingURL=refkey.d.ts.map

package/dist/src/refkey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refkey.d.ts","sourceRoot":"","sources":["../../src/refkey.ts"],"names":[],"mappings":"AAgBA,QAAA,MAAM,SAAS,EAAE,OAAO,MAAiB,CAAC;AAE1C,MAAM,MAAM,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,CAAC,SAAS,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAaxD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAMxD;AAaD,wBAAgB,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAWjD"}
+{"version":3,"file":"refkey.d.ts","sourceRoot":"","sources":["../../src/refkey.ts"],"names":[],"mappings":"AAgBA,QAAA,MAAM,SAAS,EAAE,OAAO,MAAiB,CAAC;AAE1C,MAAM,MAAM,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,CAAC,SAAS,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAaxD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAMxD;AAcD;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAWjD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEjE"}

package/dist/src/refkey.js

@@ -31,6 +31,20 @@ function getKey(value) {
   }
 }
 const knownRefkeys = new Map();
+
+/**
+ * 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) {
   const keys = args.length === 0 ? [getKey({})] : args.map(v => getKey(v));
   const compositeKey = keys.map(v => v.key).join("\u2063");
@@ -40,4 +54,30 @@ export function refkey(...args) {
   const key = createRefkey(compositeKey);
   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, member) {
+  return refkey(base, member);
 }

package/dist/src/render.d.ts

@@ -1,5 +1,6 @@
 import { Doc } from "prettier";
-import { Children, Context } from "./jsx-runtime.js";
+import { Context } from "./reactivity.js";
+import { Children, Component, Props } from "./runtime/component.js";
 /**
  * Turning components into source text involves three different trees produced
  * sequentially:
@@ -119,4 +120,7 @@ export interface PrintTreeOptions {
     tabWidth?: number;
 }
 export declare function printTree(tree: RenderedTextTree, options?: PrintTreeOptions): string;
+export declare function pushStack(component: Component<any>, props: Props): void;
+export declare function popStack(): void;
+export declare function printRenderStack(): void;
 //# sourceMappingURL=render.d.ts.map

package/dist/src/render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/render.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAO,MAAM,UAAU,CAAC;AAIpC,OAAO,EAEL,QAAQ,EACR,OAAO,EAcR,MAAM,kBAAkB,CAAC;AAwB1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,CAAC,eAAe,GAAG,UAAU,CAAC,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAID,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,gBAAgB,uBAE7D;AAED,eAAO,MAAM,YAAY,eAAW,CAAC;AAErC,MAAM,WAAW,SAAS;IACxB,CAAC,YAAY,CAAC,EAAE,IAAI,CAAC;IACrB,SAAS,CAAC,CAAC,IAAI,EAAE,gBAAgB,GAAG,gBAAgB,CAAC;IACrD,KAAK,CAAC,CACJ,IAAI,EAAE,gBAAgB,EACtB,KAAK,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,GAAG,GACxC,GAAG,CAAC;IACP,OAAO,EAAE,gBAAgB,CAAC;CAC3B;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,YAAY,GAAG,SAAS,CAAC,GACtD,SAAS,CAMX;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,SAAS,CAE5D;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAC,EAAE,CAAC;AAOzE,wBAAgB,MAAM,CACpB,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,gBAAgB,GACzB,eAAe,CAuFjB;AAED,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,oBAY5C;AAyPD,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAOD,wBAAgB,SAAS,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,gBAAgB,UAc3E"}
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/render.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAO,MAAM,UAAU,CAAC;AAKpC,OAAO,EACL,OAAO,EAQR,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAEL,QAAQ,EACR,SAAS,EAET,KAAK,EACN,MAAM,wBAAwB,CAAC;AA0BhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,CAAC,eAAe,GAAG,UAAU,CAAC,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAID,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,gBAAgB,uBAE7D;AAED,eAAO,MAAM,YAAY,eAAW,CAAC;AAErC,MAAM,WAAW,SAAS;IACxB,CAAC,YAAY,CAAC,EAAE,IAAI,CAAC;IACrB,SAAS,CAAC,CAAC,IAAI,EAAE,gBAAgB,GAAG,gBAAgB,CAAC;IACrD,KAAK,CAAC,CACJ,IAAI,EAAE,gBAAgB,EACtB,KAAK,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,GAAG,GACxC,GAAG,CAAC;IACP,OAAO,EAAE,gBAAgB,CAAC;CAC3B;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,YAAY,GAAG,SAAS,CAAC,GACtD,SAAS,CAMX;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,SAAS,CAE5D;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAC,EAAE,CAAC;AAEzE,wBAAgB,MAAM,CACpB,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,gBAAgB,GACzB,eAAe,CAuFjB;AAED,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,oBAY5C;AA4QD,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAOD,wBAAgB,SAAS,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,gBAAgB,UAc3E;AA2BD,wBAAgB,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,KAAK,QAGhE;AAED,wBAAgB,QAAQ,SAGvB;AAED,wBAAgB,gBAAgB,SAU/B"}