@b9g/crank 0.5.0-beta.2 → 0.5.0-beta.4

package/crank.d.ts

@@ -220,16 +220,16 @@ declare class Retainer<TNode> {
      * The cached child values of this element. Only host and component elements
      * will use this property.
      */
-    cached: ElementValue<TNode>;
+    cachedChildValues: ElementValue<TNode>;
     /**
      * The child which this retainer replaces. This property is used when an
      * async retainer tree replaces previously rendered elements, so that the
      * previously rendered elements can remain visible until the async tree
      * fulfills. Will be set to undefined once this subtree fully renders.
      */
-    fallback: RetainerChild<TNode>;
-    inflight: Promise<ElementValue<TNode>> | undefined;
-    onCommit: Function | undefined;
+    fallbackValue: RetainerChild<TNode>;
+    inflightValue: Promise<ElementValue<TNode>> | undefined;
+    onNextValues: Function | undefined;
     constructor(el: Element);
 }
 /**
@@ -283,7 +283,7 @@ export interface RendererImpl<TNode, TScope, TRoot extends TNode = TNode, TResul
     dispose<TTag extends string | symbol>(tag: TTag, node: TNode, props: TagProps<TTag>): unknown;
     flush(root: TRoot): unknown;
 }
-declare const $RendererImpl: unique symbol;
+declare const _RendererImpl: unique symbol;
 /**
  * An abstract class which is subclassed to render to different target
  * environments. This class is responsible for kicking off the rendering
@@ -300,7 +300,7 @@ export declare class Renderer<TNode extends object = object, TScope = unknown, T
      * A weakmap which stores element trees by root.
      */
     cache: WeakMap<object, Retainer<TNode>>;
-    [$RendererImpl]: RendererImpl<TNode, TScope, TRoot, TResult>;
+    [_RendererImpl]: RendererImpl<TNode, TScope, TRoot, TResult>;
     constructor(impl: Partial<RendererImpl<TNode, TScope, TRoot, TResult>>);
     /**
      * Renders an element tree into a specific root.
@@ -309,7 +309,7 @@ export declare class Renderer<TNode extends object = object, TScope = unknown, T
      * used root to delete the previously rendered element tree from the cache.
      * @param root - The node to be rendered into. The renderer will cache
      * element trees per root.
-     * @param ctx - An optional context that will be the ancestor context of all
+     * @param bridge - An optional context that will be the ancestor context of all
      * elements in the tree. Useful for connecting different renderers so that
      * events/provisions properly propagate. The context for a given root must be
      * the same or an error will be thrown.
@@ -329,75 +329,50 @@ export interface ProvisionMap extends Crank.ProvisionMap {
 }
 /**
  * @internal
- * The internal class which holds all context data.
+ * The internal class which holds context data.
  */
 declare class ContextImpl<TNode = unknown, TScope = unknown, TRoot extends TNode = TNode, TResult = unknown> {
-    /**
-     * flags - A bitmask. See CONTEXT FLAGS above.
-     */
+    /** A bitmask. See CONTEXT FLAGS above. */
     f: number;
+    /** The actual context associated with this impl. */
+    owner: Context<unknown, TResult>;
     /**
-     * ctx - The actual object passed as this to components.
-     */
-    ctx: Context<unknown, TResult>;
-    /**
-     * renderer - The renderer which created this context.
+     * The renderer which created this context.
      */
     renderer: RendererImpl<TNode, TScope, TRoot, TResult>;
-    /**
-     * root - The root node as set by the nearest ancestor portal.
-     */
+    /** The root node as set by the nearest ancestor portal. */
     root: TRoot | undefined;
     /**
-     * host - The nearest host or portal retainer.
+     * The nearest ancestor host or portal retainer.
      *
      * When refresh is called, the host element will be arranged as the last step
      * of the commit, to make sure the parent’s children properly reflects the
      * components’s children.
      */
     host: Retainer<TNode>;
-    /**
-     * parent - The parent context.
-     */
+    /** The parent context impl. */
     parent: ContextImpl<TNode, TScope, TRoot, TResult> | undefined;
-    /**
-     * scope - The value of the scope at the point of element’s creation.
-     */
+    /** The value of the scope at the point of element’s creation. */
     scope: TScope | undefined;
-    /**
-     * retainer - The internal node associated with this context.
-     */
+    /** The internal node associated with this context. */
     ret: Retainer<TNode>;
     /**
-     * iterator - The iterator returned by the component function.
+     * The iterator returned by the component function.
+     *
+     * Existence of this property implies that the component is a generator
+     * component. It is deleted when a component is returned.
      */
     iterator: Iterator<Children, Children | void, unknown> | AsyncIterator<Children, Children | void, unknown> | undefined;
-    /*** async properties ***/
-    /**
-     * inflightBlock
-     */
     inflightBlock: Promise<unknown> | undefined;
-    /**
-     * inflightValue
-     */
     inflightValue: Promise<ElementValue<TNode>> | undefined;
-    /**
-     * enqueuedBlock
-     */
     enqueuedBlock: Promise<unknown> | undefined;
-    /**
-     * enqueuedValue
-     */
     enqueuedValue: Promise<ElementValue<TNode>> | undefined;
-    /**
-     * onavailable - A callback used in conjunction with the IsAvailable flag to
-     * implement the props async iterator. See the Symbol.asyncIterator method
-     * and the resumeCtxIterator function.
-     */
-    onAvailable: Function | undefined;
+    onProps: ((props: Record<string, any>) => unknown) | undefined;
+    onPropsRequested: Function | undefined;
     constructor(renderer: RendererImpl<TNode, TScope, TRoot, TResult>, root: TRoot | undefined, host: Retainer<TNode>, parent: ContextImpl<TNode, TScope, TRoot, TResult> | undefined, scope: TScope | undefined, ret: Retainer<TNode>);
 }
-declare const $ContextImpl: unique symbol;
+declare const _ContextImpl: unique symbol;
+declare type ComponentProps<T> = T extends (props: infer U) => any ? U : T;
 /**
  * A class which is instantiated and passed to every component as its this
  * value. Contexts form a tree just like elements and all components in the
@@ -414,7 +389,7 @@ export declare class Context<TProps = any, TResult = any> implements EventTarget
     /**
      * @internal
      */
-    [$ContextImpl]: ContextImpl<unknown, unknown, unknown, TResult>;
+    [_ContextImpl]: ContextImpl<unknown, unknown, unknown, TResult>;
     constructor(impl: ContextImpl<unknown, unknown, unknown, TResult>);
     /**
      * The current props of the associated element.
@@ -423,7 +398,7 @@ export declare class Context<TProps = any, TResult = any> implements EventTarget
      * component or via the context iterator methods. This property is mainly for
      * plugins or utilities which wrap contexts.
      */
-    get props(): TProps;
+    get props(): ComponentProps<TProps>;
     /**
      * The current value of the associated element.
      *
@@ -432,8 +407,8 @@ export declare class Context<TProps = any, TResult = any> implements EventTarget
      * mainly for plugins or utilities which wrap contexts.
      */
     get value(): TResult;
-    [Symbol.iterator](): Generator<TProps>;
-    [Symbol.asyncIterator](): AsyncGenerator<TProps>;
+    [Symbol.iterator](): Generator<ComponentProps<TProps>>;
+    [Symbol.asyncIterator](): AsyncGenerator<ComponentProps<TProps>>;
     /**
      * Re-executes a component.
      *