@microsoft/fast-element 2.0.0-beta.6 → 2.0.0-beta.8

package/CHANGELOG.json

@@ -1,6 +1,84 @@
 {
   "name": "@microsoft/fast-element",
   "entries": [
+    {
+      "date": "Tue, 27 Sep 2022 22:31:52 GMT",
+      "tag": "@microsoft/fast-element_v2.0.0-beta.8",
+      "version": "2.0.0-beta.8",
+      "comments": {
+        "prerelease": [
+          {
+            "author": "roeisenb@microsoft.com",
+            "package": "@microsoft/fast-element",
+            "commit": "8834c6732c727d39f92f72b197388453a9c17f9b",
+            "comment": "fix: correct view state when processing unbindables during rebind"
+          },
+          {
+            "author": "roeisenb@microsoft.com",
+            "package": "@microsoft/fast-element",
+            "commit": "d949a8873621f409f9d9f3453cdb40b593d14b67",
+            "comment": "fix: do not crash when null/undefined is provided literally in templates"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Fri, 23 Sep 2022 22:53:27 GMT",
+      "tag": "@microsoft/fast-element_v2.0.0-beta.7",
+      "version": "2.0.0-beta.7",
+      "comments": {
+        "prerelease": [
+          {
+            "author": "roeisenb@microsoft.com",
+            "package": "@microsoft/fast-element",
+            "commit": "1646b26450a08a77c8bd6302560fe12cc6989ae1",
+            "comment": "feat: improve parent typing and fix repeat context type bug"
+          },
+          {
+            "author": "roeisenb@microsoft.com",
+            "package": "@microsoft/fast-element",
+            "commit": "0d786392a38e1d83e56fb1e2112a3e571d193c11",
+            "comment": "feat: prepare fast-element for scoped element registries"
+          },
+          {
+            "author": "wendywendy@microsoft.com",
+            "package": "@microsoft/fast-element",
+            "commit": "a42ff75a9130a5ce13006c272c2e2bbbaffdbb41",
+            "comment": "persist totalAvailableViews to compare against removeIndex"
+          },
+          {
+            "author": "863023+radium-v@users.noreply.github.com",
+            "package": "@microsoft/fast-element",
+            "commit": "ec2b158dcf39c8b4152b22c3b65963046b473e17",
+            "comment": "make ElementsFilter type arguments optional"
+          },
+          {
+            "author": "roeisenb@microsoft.com",
+            "package": "@microsoft/fast-element",
+            "commit": "1039218eafa9a8dbea9da94e1c7803de48d1484c",
+            "comment": "fix(fast-element): attributes properly located in inheritance hierarchy"
+          },
+          {
+            "author": "nicholasrice@users.noreply.github.com",
+            "package": "@microsoft/fast-element",
+            "commit": "c1909e9899d517f9483b24043d49a8b193af3c26",
+            "comment": "Adds PendingTask community protocol"
+          },
+          {
+            "author": "roeisenb@microsoft.com",
+            "package": "@microsoft/fast-element",
+            "commit": "2edd63a8abe24c68cfc7c76d773c912c6f2d6543",
+            "comment": "feat: new behavior and context API design"
+          },
+          {
+            "author": "roeisenb@microsoft.com",
+            "package": "@microsoft/fast-element",
+            "commit": "eb62934b258334c7f92ab3a1112ea62b3901cdac",
+            "comment": "feat: implement getAsync code path for dependency injection"
+          }
+        ]
+      }
+    },
     {
       "date": "Thu, 01 Sep 2022 21:53:34 GMT",
       "tag": "@microsoft/fast-element_v2.0.0-beta.6",

package/CHANGELOG.md

@@ -1,9 +1,33 @@
 # Change Log - @microsoft/fast-element
 
-This log was last generated on Thu, 01 Sep 2022 21:53:34 GMT and should not be manually modified.
+This log was last generated on Tue, 27 Sep 2022 22:31:52 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 2.0.0-beta.8
+
+Tue, 27 Sep 2022 22:31:52 GMT
+
+### Changes
+
+- fix: correct view state when processing unbindables during rebind (roeisenb@microsoft.com)
+- fix: do not crash when null/undefined is provided literally in templates (roeisenb@microsoft.com)
+
+## 2.0.0-beta.7
+
+Fri, 23 Sep 2022 22:53:27 GMT
+
+### Changes
+
+- feat: improve parent typing and fix repeat context type bug (roeisenb@microsoft.com)
+- feat: prepare fast-element for scoped element registries (roeisenb@microsoft.com)
+- persist totalAvailableViews to compare against removeIndex (wendywendy@microsoft.com)
+- make ElementsFilter type arguments optional (863023+radium-v@users.noreply.github.com)
+- fix(fast-element): attributes properly located in inheritance hierarchy (roeisenb@microsoft.com)
+- Adds PendingTask community protocol (nicholasrice@users.noreply.github.com)
+- feat: new behavior and context API design (roeisenb@microsoft.com)
+- feat: implement getAsync code path for dependency injection (roeisenb@microsoft.com)
+
 ## 2.0.0-beta.6
 
 Thu, 01 Sep 2022 21:53:34 GMT

package/dist/dts/components/attributes.d.ts

@@ -40,6 +40,16 @@ export declare type AttributeConfiguration = {
     mode?: AttributeMode;
     converter?: ValueConverter;
 };
+/**
+ * Metadata used to configure a custom attribute's behavior.
+ * @public
+ */
+export declare const AttributeConfiguration: Readonly<{
+    /**
+     * Locates all attribute configurations associated with a type.
+     */
+    locate: (target: {}) => AttributeConfiguration[];
+}>;
 /**
  * Metadata used to configure a custom attribute's behavior through a decorator.
  * @public

package/dist/dts/components/{controller.d.ts → element-controller.d.ts}

@@ -1,21 +1,21 @@
-import type { Behavior } from "../observation/behavior.js";
+import type { HostBehavior, HostController } from "../styles/host.js";
 import { PropertyChangeNotifier } from "../observation/notifier.js";
-import type { ElementStyles } from "../styles/element-styles.js";
 import type { ElementViewTemplate } from "../templating/template.js";
 import type { ElementView } from "../templating/view.js";
+import type { ElementStyles } from "../styles/element-styles.js";
 import { FASTElementDefinition } from "./fast-definitions.js";
 /**
  * Controls the lifecycle and rendering of a `FASTElement`.
  * @public
  */
-export declare class Controller<TElement extends HTMLElement = HTMLElement> extends PropertyChangeNotifier {
+export declare class ElementController<TElement extends HTMLElement = HTMLElement> extends PropertyChangeNotifier implements HostController<TElement> {
     private boundObservables;
-    private behaviors;
     private needsInitialization;
     private hasExistingShadowRoot;
     private _template;
-    private _styles;
     private _isConnected;
+    private behaviors;
+    private _mainStyles;
     /**
      * This allows Observable.getNotifier(...) to return the Controller
      * when the notifier for the Controller itself is being requested. The
@@ -28,7 +28,7 @@ export declare class Controller<TElement extends HTMLElement = HTMLElement> exte
     /**
      * The element being controlled by this controller.
      */
-    readonly element: TElement;
+    readonly source: TElement;
     /**
      * The element definition that instructs this controller
      * in how to handle rendering and other platform integrations.
@@ -54,12 +54,11 @@ export declare class Controller<TElement extends HTMLElement = HTMLElement> exte
     get template(): ElementViewTemplate<TElement> | null;
     set template(value: ElementViewTemplate<TElement> | null);
     /**
-     * Gets/sets the primary styles used for the component.
-     * @remarks
-     * This value can only be accurately read after connect but can be set at any time.
+     * The main set of styles used for the component, independent
+     * of any dynamically added styles.
      */
-    get styles(): ElementStyles | null;
-    set styles(value: ElementStyles | null);
+    get mainStyles(): ElementStyles | null;
+    set mainStyles(value: ElementStyles | null);
     /**
      * Creates a Controller to control the specified element.
      * @param element - The element to be controlled by this controller.
@@ -68,6 +67,17 @@ export declare class Controller<TElement extends HTMLElement = HTMLElement> exte
      * @internal
      */
     constructor(element: TElement, definition: FASTElementDefinition);
+    /**
+     * Adds the behavior to the component.
+     * @param behavior - The behavior to add.
+     */
+    addBehavior(behavior: HostBehavior<TElement>): void;
+    /**
+     * Removes the behavior from the component.
+     * @param behavior - The behavior to remove.
+     * @param force - Forces removal even if this behavior was added more than once.
+     */
+    removeBehavior(behavior: HostBehavior<TElement>, force?: boolean): void;
     /**
      * Adds styles to this element. Providing an HTMLStyleElement will attach the element instance to the shadowRoot.
      * @param styles - The styles to add.
@@ -78,25 +88,14 @@ export declare class Controller<TElement extends HTMLElement = HTMLElement> exte
      * @param styles - the styles to remove.
      */
     removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
-    /**
-     * Adds behaviors to this element.
-     * @param behaviors - The behaviors to add.
-     */
-    addBehaviors(behaviors: ReadonlyArray<Behavior<TElement>>): void;
-    /**
-     * Removes behaviors from this element.
-     * @param behaviors - The behaviors to remove.
-     * @param force - Forces unbinding of behaviors.
-     */
-    removeBehaviors(behaviors: ReadonlyArray<Behavior<TElement>>, force?: boolean): void;
     /**
      * Runs connected lifecycle behavior on the associated element.
      */
-    onConnectedCallback(): void;
+    connect(): void;
     /**
      * Runs disconnected lifecycle behavior on the associated element.
      */
-    onDisconnectedCallback(): void;
+    disconnect(): void;
     /**
      * Runs the attribute changed callback for the associated element.
      * @param name - The name of the attribute that changed.
@@ -123,5 +122,5 @@ export declare class Controller<TElement extends HTMLElement = HTMLElement> exte
      * registered either through the use of the {@link customElement}
      * decorator or a call to `FASTElement.define`.
      */
-    static forCustomElement(element: HTMLElement): Controller;
+    static forCustomElement(element: HTMLElement): ElementController;
 }

package/dist/dts/components/fast-definitions.d.ts

@@ -2,6 +2,18 @@ import { Constructable } from "../interfaces.js";
 import { ComposableStyles, ElementStyles } from "../styles/element-styles.js";
 import type { ElementViewTemplate } from "../templating/template.js";
 import { AttributeConfiguration, AttributeDefinition } from "./attributes.js";
+/**
+ * Shadow root initialization options.
+ * @public
+ */
+export interface ShadowRootOptions extends ShadowRootInit {
+    /**
+     * A registry that provides the custom elements visible
+     * from within this shadow root.
+     * @beta
+     */
+    registry?: CustomElementRegistry;
+}
 /**
  * Represents metadata configuration for a custom element.
  * @public
@@ -25,12 +37,21 @@ export interface PartialFASTElementDefinition {
     readonly attributes?: (AttributeConfiguration | string)[];
     /**
      * Options controlling the creation of the custom element's shadow DOM.
+     * @remarks
+     * If not provided, defaults to an open shadow root. Provide null
+     * to render to the associated template to the light DOM instead.
      */
-    readonly shadowOptions?: Partial<ShadowRootInit> | null;
+    readonly shadowOptions?: Partial<ShadowRootOptions> | null;
     /**
      * Options controlling how the custom element is defined with the platform.
      */
     readonly elementOptions?: ElementDefinitionOptions;
+    /**
+     * The registry to register this component in by default.
+     * @remarks
+     * If not provided, defaults to the global registry.
+     */
+    readonly registry?: CustomElementRegistry;
 }
 /**
  * Defines metadata for a FASTElement.
@@ -73,11 +94,15 @@ export declare class FASTElementDefinition<TType extends Constructable<HTMLEleme
     /**
      * Options controlling the creation of the custom element's shadow DOM.
      */
-    readonly shadowOptions?: ShadowRootInit;
+    readonly shadowOptions?: ShadowRootOptions;
     /**
      * Options controlling how the custom element is defined with the platform.
      */
-    readonly elementOptions?: ElementDefinitionOptions;
+    readonly elementOptions: ElementDefinitionOptions;
+    /**
+     * The registry to register this component in by default.
+     */
+    readonly registry: CustomElementRegistry;
     private constructor();
     /**
      * Defines a custom element based on this definition.

package/dist/dts/components/fast-element.d.ts

@@ -1,5 +1,5 @@
 import { Constructable } from "../interfaces.js";
-import { Controller } from "./controller.js";
+import { ElementController } from "./element-controller.js";
 import { FASTElementDefinition, PartialFASTElementDefinition } from "./fast-definitions.js";
 /**
  * Represents a custom element based on the FASTElement infrastructure.
@@ -10,7 +10,7 @@ export interface FASTElement extends HTMLElement {
      * The underlying controller that handles the lifecycle and rendering of
      * this FASTElement.
      */
-    readonly $fastController: Controller;
+    readonly $fastController: ElementController;
     /**
      * Emits a custom HTML event.
      * @param type - The type name of the event.

package/dist/dts/di/di.d.ts

@@ -17,6 +17,7 @@ export declare type ResolveCallback<T = any> = (handler: Container, requestor: C
 interface ResolverLike<C, K = any> {
     readonly $isResolver: true;
     resolve(handler: C, requestor: C): Resolved<K>;
+    resolveAsync(handler: C, requestor: C): Promise<Resolved<K>>;
     getFactory?(container: C): (K extends Constructable ? Factory<K> : never) | null;
 }
 /**
@@ -68,6 +69,13 @@ export interface Factory<T extends Constructable = any> {
      * @param dynamicDependencies - Dynamic dependencies supplied to the constructor.
      */
     construct(container: Container, dynamicDependencies?: Key[]): Resolved<T>;
+    /**
+     * Constructs an instance of the factory's object, allowing for
+     * async resolution of dependencies.
+     * @param container - The container the object is being constructor for.
+     * @param dynamicDependencies - Dynamic dependencies supplied to the constructor.
+     */
+    constructAsync(container: Container, dynamicDependencies?: Key[]): Promise<Resolved<T>>;
 }
 /**
  * Implemented by objects capable of resolving services and other dependencies.
@@ -96,6 +104,24 @@ export interface ServiceLocator {
      * @param key - The key to lookup.
      */
     get<K extends Key>(key: K | Key): Resolved<K>;
+    /**
+     * Gets a dependency by key, allowing for asynchronously
+     * resolved dependencies.
+     * @param key - The key to lookup.
+     */
+    getAsync<K extends Key>(key: K): Promise<Resolved<K>>;
+    /**
+     * Gets a dependency by key, allowing for asynchronously
+     * resolved dependencies.
+     * @param key - The key to lookup.
+     */
+    getAsync<K extends Key>(key: Key): Promise<Resolved<K>>;
+    /**
+     * Gets a dependency by key, allowing for asynchronously
+     * resolved dependencies.
+     * @param key - The key to lookup.
+     */
+    getAsync<K extends Key>(key: K | Key): Promise<Resolved<K>>;
     /**
      * Gets an array of all dependencies by key.
      * @param key - The key to lookup.
@@ -285,6 +311,11 @@ export declare type Injectable<T = {}> = Constructable<T> & {
  * @public
  */
 export declare type ParentLocator = (owner: any) => Container | null;
+/**
+ * A function capable of asynchronously locating a resolver for a key.
+ * @public
+ */
+export declare type AsyncRegistrationLocator = (key: Key) => Promise<Registration | null>;
 /**
  * Configuration for a dependency injection container.
  * @public
@@ -294,6 +325,12 @@ export interface ContainerConfiguration {
      * The locator function used to find the parent of the container.
      */
     parentLocator: ParentLocator;
+    /**
+     * When an asynchronous get request is made to the container, if no
+     * resolver is found for the key, this function is called to provide
+     * a registration.
+     */
+    asyncRegistrationLocator: AsyncRegistrationLocator;
     /**
      * Indicates whether this container should resolve dependencies that are directly made
      * by its owner. The default is "false" which results in the parent container being used.
@@ -712,6 +749,7 @@ export declare class ResolverImpl implements Resolver, Registration {
     get $isResolver(): true;
     private resolving;
     register(container: Container): Resolver;
+    resolveAsync(handler: Container, requestor: Container): Promise<any>;
     resolve(handler: Container, requestor: Container): any;
     getFactory(container: Container): Factory | null;
 }
@@ -721,7 +759,9 @@ export declare class FactoryImpl<T extends Constructable = any> implements Facto
     private readonly dependencies;
     private transformers;
     constructor(Type: T, dependencies: Key[]);
+    constructAsync(container: Container, dynamicDependencies?: Key[]): Promise<Resolved<T>>;
     construct(container: Container, dynamicDependencies?: Key[]): Resolved<T>;
+    private constructCore;
     registerTransformer(transformer: (instance: any) => any): void;
 }
 /**
@@ -744,6 +784,7 @@ export declare class ContainerImpl implements DOMContainer {
     registerTransformer<K extends Key, T = K>(key: K, transformer: Transformer<T>): boolean;
     getResolver<K extends Key, T = K>(key: K | Key, autoRegister?: boolean): Resolver<T> | null;
     has<K extends Key>(key: K, searchAncestors?: boolean): boolean;
+    getAsync<K extends Key>(key: K): Promise<Resolved<K>>;
     get<K extends Key>(key: K): Resolved<K>;
     getAll<K extends Key>(key: K, searchAncestors?: boolean): readonly Resolved<K>[];
     getFactory<K extends Constructable>(Type: K): Factory<K>;

package/dist/dts/index.d.ts

@@ -4,10 +4,10 @@ export * from "./observation/observable.js";
 export * from "./observation/notifier.js";
 export * from "./observation/arrays.js";
 export * from "./observation/update-queue.js";
-export type { Behavior } from "./observation/behavior.js";
 export * from "./styles/element-styles.js";
 export * from "./styles/css.js";
 export * from "./styles/css-directive.js";
+export * from "./styles/host.js";
 export * from "./templating/dom.js";
 export * from "./templating/template.js";
 export * from "./templating/compiler.js";
@@ -24,4 +24,4 @@ export * from "./templating/node-observation.js";
 export * from "./components/fast-element.js";
 export * from "./components/fast-definitions.js";
 export * from "./components/attributes.js";
-export * from "./components/controller.js";
+export * from "./components/element-controller.js";

package/dist/dts/observation/observable.d.ts

@@ -42,23 +42,77 @@ export interface ObservationRecord {
     propertyName: string;
 }
 /**
- * Observes a binding for changes.
- *
+ * Describes how the source's lifetime relates to its controller's lifetime.
  * @public
  */
-export interface ExpressionObserver<TSource = any, TReturn = any, TParent = any> extends Disposable {
+export declare const SourceLifetime: Readonly<{
     /**
-     * Begins observing the binding.
-     * @param source - The source to pass to the binding.
-     * @param context - The context to pass to the binding.
+     * The source to controller lifetime relationship is unknown.
      */
-    observe(source: TSource, context?: ExecutionContext<TParent>): TReturn;
+    readonly unknown: undefined;
+    /**
+     * The source and controller lifetimes are coupled to one another.
+     * They can/will be GC'd together.
+     */
+    readonly coupled: 1;
+}>;
+/**
+ * Describes how the source's lifetime relates to its controller's lifetime.
+ * @public
+ */
+export declare type SourceLifetime = typeof SourceLifetime[keyof typeof SourceLifetime];
+/**
+ * Controls the lifecycle of an expression and provides relevant context.
+ * @public
+ */
+export interface ExpressionController<TSource = any, TParent = any> {
+    /**
+     * The source the expression is evaluated against.
+     */
+    readonly source: TSource;
+    /**
+     * Indicates how the source's lifetime relates to the controller's lifetime.
+     */
+    readonly sourceLifetime?: SourceLifetime;
+    /**
+     * The context the expression is evaluated against.
+     */
+    readonly context: ExecutionContext<TParent>;
+    /**
+     * Indicates whether the controller is bound.
+     */
+    readonly isBound: boolean;
+    /**
+     * Registers an unbind handler with the controller.
+     * @param behavior - An object to call when the controller unbinds.
+     */
+    onUnbind(behavior: {
+        unbind(controller: ExpressionController<TSource, TParent>): any;
+    }): void;
+}
+/**
+ * Observes an expression for changes.
+ * @public
+ */
+export interface ExpressionObserver<TSource = any, TReturn = any, TParent = any> {
+    /**
+     * Binds the expression to the source.
+     * @param controller - The controller that manages the lifecycle and related
+     * context for the expression.
+     */
+    bind(controller: ExpressionController<TSource, TParent>): TReturn;
 }
 /**
  * Enables evaluation of and subscription to a binding.
  * @public
  */
-export interface ExpressionNotifier<TSource = any, TReturn = any, TParent = any> extends Notifier, ExpressionObserver<TSource, TReturn, TParent> {
+export interface ExpressionNotifier<TSource = any, TReturn = any, TParent = any> extends Notifier, ExpressionObserver<TSource, TReturn, TParent>, Disposable {
+    /**
+     * Observes the expression.
+     * @param source - The source for the expression.
+     * @param context - The context for the expression.
+     */
+    observe(source: TSource, context?: ExecutionContext): TReturn;
     /**
      * Gets {@link ObservationRecord|ObservationRecords} that the {@link ExpressionNotifier}
      * is observing.
@@ -153,11 +207,7 @@ export declare function volatile(target: {}, name: string | Accessor, descriptor
  * Provides additional contextual information available to behaviors and expressions.
  * @public
  */
-export declare class ExecutionContext<TParentSource = any> {
-    /**
-     * The default execution context.
-     */
-    static readonly default: ExecutionContext<any>;
+export interface ExecutionContext<TParent = any> {
     /**
      * The index of the current item within a repeat context.
      */
@@ -169,41 +219,40 @@ export declare class ExecutionContext<TParentSource = any> {
     /**
      * The parent data source within a nested context.
      */
-    readonly parent: TParentSource;
+    parent: TParent;
     /**
      * The parent execution context when in nested context scenarios.
      */
-    readonly parentContext: ExecutionContext<TParentSource>;
-    private constructor();
+    parentContext: ExecutionContext<TParent>;
     /**
      * The current event within an event handler.
      */
-    get event(): Event;
+    readonly event: Event;
     /**
      * Indicates whether the current item within a repeat context
      * has an even index.
      */
-    get isEven(): boolean;
+    readonly isEven: boolean;
     /**
      * Indicates whether the current item within a repeat context
      * has an odd index.
      */
-    get isOdd(): boolean;
+    readonly isOdd: boolean;
     /**
      * Indicates whether the current item within a repeat context
      * is the first item in the collection.
      */
-    get isFirst(): boolean;
+    readonly isFirst: boolean;
     /**
      * Indicates whether the current item within a repeat context
      * is somewhere in the middle of the collection.
      */
-    get isInMiddle(): boolean;
+    readonly isInMiddle: boolean;
     /**
      * Indicates whether the current item within a repeat context
      * is the last item in the collection.
      */
-    get isLast(): boolean;
+    readonly isLast: boolean;
     /**
      * Returns the typed event detail of a custom event.
      */
@@ -212,34 +261,24 @@ export declare class ExecutionContext<TParentSource = any> {
      * Returns the typed event target of the event.
      */
     eventTarget<TTarget extends EventTarget>(): TTarget;
+}
+/**
+ * Provides additional contextual information available to behaviors and expressions.
+ * @public
+ */
+export declare const ExecutionContext: Readonly<{
     /**
-     * Updates the position/size on a context associated with a list item.
-     * @param index - The new index of the item.
-     * @param length - The new length of the list.
-     */
-    updatePosition(index: number, length: number): void;
-    /**
-     * Creates a new execution context descendent from the current context.
-     * @param source - The source for the context if different than the parent.
-     * @returns A child execution context.
-     */
-    createChildContext<TParentSource>(parentSource: TParentSource): ExecutionContext<TParentSource>;
-    /**
-     * Creates a new execution context descent suitable for use in list rendering.
-     * @param item - The list item to serve as the source.
-     * @param index - The index of the item in the list.
-     * @param length - The length of the list.
+     * A default execution context.
      */
-    createItemContext(index: number, length: number): ExecutionContext<TParentSource>;
+    default: ExecutionContext<any>;
     /**
-     * Sets the event for the current execution context.
-     * @param event - The event to set.
-     * @internal
+     * Gets the current event.
+     * @returns An event object.
      */
-    static setEvent(event: Event | null): void;
+    getEvent(): Event | null;
     /**
-     * Creates a new root execution context.
-     * @returns A new execution context.
+     * Sets the current event.
+     * @param event - An event object.
      */
-    static create(): ExecutionContext;
-}
+    setEvent(event: Event | null): void;
+}>;

package/dist/dts/pending-task.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This module provides
+ */
+/**
+ * An implementation of the https://github.com/webcomponents-cg/community-protocols/blob/main/proposals/pending-task.md proposal.
+ * @beta
+ */
+export interface PendingTask extends Event {
+    complete: Promise<void>;
+}
+/**
+ * A concrete implementation of {@link PendingTask}
+ * @beta
+ */
+export declare class PendingTaskEvent extends Event implements PendingTask {
+    complete: Promise<void>;
+    static readonly type = "pending-task";
+    constructor(complete: Promise<void>);
+    static isPendingTask<T extends Event>(value: T | PendingTask): value is PendingTask;
+}

package/dist/dts/platform.d.ts

@@ -33,3 +33,9 @@ export interface TypeRegistry<TDefinition extends TypeDefinition> {
  * @internal
  */
 export declare function createTypeRegistry<TDefinition extends TypeDefinition>(): TypeRegistry<TDefinition>;
+/**
+ * Creates a function capable of locating metadata associated with a type.
+ * @returns A metadata locator function.
+ * @internal
+ */
+export declare function createMetadataLocator<TMetadata>(): (target: {}) => TMetadata[];