@microsoft/fast-element 2.0.0-beta.2 → 2.0.0-beta.5

package/dist/dts/templating/render.d.ts

@@ -0,0 +1,277 @@
+import type { FASTElement } from "../components/fast-element.js";
+import { Constructable } from "../interfaces.js";
+import type { Behavior } from "../observation/behavior.js";
+import type { Subscriber } from "../observation/notifier.js";
+import type { ExecutionContext, Expression, ExpressionObserver } from "../observation/observable.js";
+import { ContentTemplate, ContentView } from "./binding.js";
+import { AddViewBehaviorFactory, Binding, HTMLDirective, ViewBehaviorFactory, ViewBehaviorTargets } from "./html-directive.js";
+import { CaptureType, SyntheticViewTemplate, TemplateValue, ViewTemplate } from "./template.js";
+/**
+ * A Behavior that enables advanced rendering.
+ * @public
+ */
+export declare class RenderBehavior<TSource = any, TParent = any> implements Behavior, Subscriber {
+    private directive;
+    private location;
+    private source;
+    private view;
+    private template;
+    private templateBindingObserver;
+    private data;
+    private dataBindingObserver;
+    private originalContext;
+    private childContext;
+    /**
+     * Creates an instance of RenderBehavior.
+     * @param location - A Node representing the location where this behavior will render.
+     * @param dataBinding - A binding expression that returns the data to render.
+     * @param templateBinding - A binding expression that returns the template to use with the data.
+     */
+    constructor(directive: RenderDirective, location: Node);
+    /**
+     * Bind this behavior to the source.
+     * @param source - The source to bind to.
+     * @param context - The execution context that the binding is operating within.
+     */
+    bind(source: TSource, context: ExecutionContext): void;
+    /**
+     * Unbinds this behavior from the source.
+     * @param source - The source to unbind from.
+     */
+    unbind(source: TSource, context: ExecutionContext<TParent>): void;
+    /** @internal */
+    handleChange(source: any, observer: ExpressionObserver): void;
+    private refreshView;
+}
+/**
+ * A Directive that enables use of the RenderBehavior.
+ * @public
+ */
+export declare class RenderDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
+    readonly dataBinding: Binding<TSource>;
+    readonly templateBinding: Binding<TSource, ContentTemplate>;
+    readonly templateBindingDependsOnData: boolean;
+    /**
+     * The unique id of the factory.
+     */
+    id: string;
+    /**
+     * The structural id of the DOM node to which the created behavior will apply.
+     */
+    nodeId: string;
+    /**
+     * Creates an instance of RenderDirective.
+     * @param dataBinding - A binding expression that returns the data to render.
+     * @param templateBinding - A binding expression that returns the template to use to render the data.
+     */
+    constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, ContentTemplate>, templateBindingDependsOnData: boolean);
+    /**
+     * Creates HTML to be used within a template.
+     * @param add - Can be used to add  behavior factories to a template.
+     */
+    createHTML(add: AddViewBehaviorFactory): string;
+    /**
+     * Creates a behavior.
+     * @param targets - The targets available for behaviors to be attached to.
+     */
+    createBehavior(targets: ViewBehaviorTargets): RenderBehavior<TSource>;
+}
+/**
+ * Provides instructions for how to render a type.
+ * @public
+ */
+export interface RenderInstruction {
+    /**
+     * Identifies this as a RenderInstruction.
+     */
+    brand: symbol;
+    /**
+     * The type this instruction is associated with.
+     */
+    type: Constructable;
+    /**
+     * The template to use when rendering.
+     */
+    template: ContentTemplate;
+    /**
+     * A name that can be used to identify the instruction.
+     */
+    name: string;
+}
+/**
+ * Render options that are common to all configurations.
+ * @public
+ */
+export declare type CommonRenderOptions = {
+    /**
+     * The type this instruction is associated with.
+     */
+    type: Constructable;
+    /**
+     * A name that can be used to identify the instruction.
+     */
+    name?: string;
+};
+/**
+ * Render options used to specify a template.
+ * @public
+ */
+export declare type TemplateRenderOptions = CommonRenderOptions & {
+    /**
+     * The template to use when rendering.
+     */
+    template: ContentTemplate;
+};
+/**
+ * Render options that are common to all element render instructions.
+ * @public
+ */
+export declare type BaseElementRenderOptions<TSource = any, TParent = any> = CommonRenderOptions & {
+    /**
+     * Attributes to use when creating the element template.
+     */
+    attributes?: Record<string, string | TemplateValue<TSource, TParent>>;
+    /**
+     * Content to use when creating the element template.
+     */
+    content?: string | SyntheticViewTemplate;
+};
+/**
+ * Render options used to specify an element.
+ * @public
+ */
+export declare type ElementConstructorRenderOptions<TSource = any, TParent = any> = BaseElementRenderOptions<TSource, TParent> & {
+    /**
+     * The element to use when rendering.
+     */
+    element: Constructable<FASTElement>;
+};
+/**
+ * Render options use to specify an element by tag name.
+ * @public
+ */
+export declare type TagNameRenderOptions<TSource = any, TParent = any> = BaseElementRenderOptions<TSource, TParent> & {
+    /**
+     * The tag name to use when rendering.
+     */
+    tagName: string;
+};
+declare function createElementTemplate<TSource = any, TParent = any>(tagName: string, attributes?: Record<string, string | TemplateValue<TSource, TParent>>, content?: string | ContentTemplate): ViewTemplate<TSource, TParent>;
+declare function create(options: TagNameRenderOptions): RenderInstruction;
+declare function create(options: ElementConstructorRenderOptions): RenderInstruction;
+declare function create(options: TemplateRenderOptions): RenderInstruction;
+declare function instanceOf(object: any): object is RenderInstruction;
+declare function register(options: TagNameRenderOptions): RenderInstruction;
+declare function register(options: ElementConstructorRenderOptions): RenderInstruction;
+declare function register(options: TemplateRenderOptions): RenderInstruction;
+declare function register(instruction: RenderInstruction): RenderInstruction;
+declare function getByType(type: Constructable, name?: string): RenderInstruction | undefined;
+declare function getForInstance(object: any, name?: string): RenderInstruction | undefined;
+/**
+ * Provides APIs for creating and interacting with render instructions.
+ * @public
+ */
+export declare const RenderInstruction: Readonly<{
+    /**
+     * Checks whether the provided object is a RenderInstruction.
+     * @param object - The object to check.
+     * @returns true if the object is a RenderInstruction; false otherwise
+     */
+    instanceOf: typeof instanceOf;
+    /**
+     * Creates a RenderInstruction for a set of options.
+     * @param options - The options to use when creating the RenderInstruction.
+     */
+    create: typeof create;
+    /**
+     * Creates a template based on a tag name.
+     * @param tagName - The tag name to use when creating the template.
+     * @param attributes - The attributes to apply to the element.
+     * @param content - The content to insert into the element.
+     * @returns A template based on the provided specifications.
+     */
+    createElementTemplate: typeof createElementTemplate;
+    /**
+     * Creates and registers an instruction.
+     * @param options The options to use when creating the RenderInstruction.
+     * @remarks
+     * A previously created RenderInstruction can also be registered.
+     */
+    register: typeof register;
+    /**
+     * Finds a previously registered RenderInstruction by type and optionally by name.
+     * @param type - The type to retrieve the RenderInstruction for.
+     * @param name - An optional name used in differentiating between multiple registered instructions.
+     * @returns The located RenderInstruction that matches the criteria or undefined if none is found.
+     */
+    getByType: typeof getByType;
+    /**
+     * Finds a previously registered RenderInstruction for the instance's type and optionally by name.
+     * @param object - The instance to retrieve the RenderInstruction for.
+     * @param name - An optional name used in differentiating between multiple registered instructions.
+     * @returns The located RenderInstruction that matches the criteria or undefined if none is found.
+     */
+    getForInstance: typeof getForInstance;
+}>;
+/**
+ * Decorates a type with render instruction metadata.
+ * @param options - The options used in creating the RenderInstruction.
+ * @public
+ */
+export declare function renderWith(options: Omit<TagNameRenderOptions, "type">): ClassDecorator;
+/**
+ * Decorates a type with render instruction metadata.
+ * @param options - The options used in creating the RenderInstruction.
+ * @public
+ */
+export declare function renderWith(options: Omit<ElementConstructorRenderOptions, "type">): ClassDecorator;
+/**
+ * Decorates a type with render instruction metadata.
+ * @param options - The options used in creating the RenderInstruction.
+ * @public
+ */
+export declare function renderWith(options: Omit<TemplateRenderOptions, "type">): ClassDecorator;
+/**
+ * Decorates a type with render instruction metadata.
+ * @param element - The element to use to render the decorated class.
+ * @param name - An optional name to differentiate the render instruction.
+ * @public
+ */
+export declare function renderWith(element: Constructable<FASTElement>, name?: string): ClassDecorator;
+/**
+ * Decorates a type with render instruction metadata.
+ * @param template - The template to use to render the decorated class.
+ * @param name - An optional name to differentiate the render instruction.
+ * @public
+ */
+export declare function renderWith(template: ContentTemplate, name?: string): ClassDecorator;
+/**
+ * @internal
+ */
+export declare class NodeTemplate implements ContentTemplate, ContentView {
+    readonly node: Node;
+    constructor(node: Node);
+    bind(source: any, context: ExecutionContext<any>): void;
+    unbind(): void;
+    insertBefore(refNode: Node): void;
+    remove(): void;
+    create(): ContentView;
+}
+/**
+ * Creates a RenderDirective for use in advanced rendering scenarios.
+ * @param value - The binding expression that returns the data to be rendered. The expression
+ * can also return a Node to render directly.
+ * @param template - A template to render the data with
+ * or a string to indicate which RenderInstruction to use when looking up a RenderInstruction.
+ * Expressions can also be provided to dynamically determine either the template or the name.
+ * @returns A RenderDirective suitable for use in a template.
+ * @remarks
+ * If no binding is provided, then a default binding that returns the source is created.
+ * If no template is provided, then a binding is created that will use registered
+ * RenderInstructions to determine the view.
+ * If the template binding returns a string, then it will be used to look up a
+ * RenderInstruction to determine the view.
+ * @public
+ */
+export declare function render<TSource = any, TItem = any>(value?: Expression<TSource, TItem> | Binding<TSource, TItem> | {}, template?: ContentTemplate | string | Expression<TSource, ContentTemplate | string | Node> | Binding<TSource, ContentTemplate | string | Node>): CaptureType<TSource>;
+export {};

package/dist/dts/templating/repeat.d.ts

@@ -1,8 +1,8 @@
 import type { Behavior } from "../observation/behavior.js";
 import type { Subscriber } from "../observation/notifier.js";
-import { Binding, ExecutionContext } from "../observation/observable.js";
+import { ExecutionContext, Expression, ExpressionObserver } from "../observation/observable.js";
 import { Splice } from "../observation/arrays.js";
-import { AddViewBehaviorFactory, HTMLDirective, ViewBehaviorFactory, ViewBehaviorTargets } from "./html-directive.js";
+import { AddViewBehaviorFactory, Binding, HTMLDirective, ViewBehaviorFactory, ViewBehaviorTargets } from "./html-directive.js";
 import type { CaptureType, SyntheticViewTemplate, ViewTemplate } from "./template.js";
 /**
  * Options for configuring repeat behavior.
@@ -23,10 +23,8 @@ export interface RepeatOptions {
  * @public
  */
 export declare class RepeatBehavior<TSource = any> implements Behavior, Subscriber {
+    private directive;
     private location;
-    private itemsBinding;
-    private templateBinding;
-    private options;
     private source;
     private views;
     private template;
@@ -40,13 +38,13 @@ export declare class RepeatBehavior<TSource = any> implements Behavior, Subscrib
     /**
      * Creates an instance of RepeatBehavior.
      * @param location - The location in the DOM to render the repeat.
-     * @param itemsBinding - The array to render.
+     * @param dataBinding - The array to render.
      * @param isItemsBindingVolatile - Indicates whether the items binding has volatile dependencies.
      * @param templateBinding - The template to render for each item.
      * @param isTemplateBindingVolatile - Indicates whether the template binding has volatile dependencies.
      * @param options - Options used to turn on special repeat features.
      */
-    constructor(location: Node, itemsBinding: Binding<TSource, any[]>, isItemsBindingVolatile: boolean, templateBinding: Binding<TSource, SyntheticViewTemplate>, isTemplateBindingVolatile: boolean, options: RepeatOptions);
+    constructor(directive: RepeatDirective, location: Node);
     /**
      * Bind this behavior to the source.
      * @param source - The source to bind to.
@@ -63,7 +61,7 @@ export declare class RepeatBehavior<TSource = any> implements Behavior, Subscrib
      * @param source - The source of the change.
      * @param args - The details about what was changed.
      */
-    handleChange(source: any, args: Splice[]): void;
+    handleChange(source: any, args: Splice[] | ExpressionObserver): void;
     private observeItems;
     private updateViews;
     private refreshAllViews;
@@ -74,11 +72,9 @@ export declare class RepeatBehavior<TSource = any> implements Behavior, Subscrib
  * @public
  */
 export declare class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
-    readonly itemsBinding: Binding;
+    readonly dataBinding: Binding<TSource>;
     readonly templateBinding: Binding<TSource, SyntheticViewTemplate>;
     readonly options: RepeatOptions;
-    private isItemsBindingVolatile;
-    private isTemplateBindingVolatile;
     /**
      * The unique id of the factory.
      */
@@ -94,11 +90,11 @@ export declare class RepeatDirective<TSource = any> implements HTMLDirective, Vi
     createHTML(add: AddViewBehaviorFactory): string;
     /**
      * Creates an instance of RepeatDirective.
-     * @param itemsBinding - The binding that provides the array to render.
+     * @param dataBinding - The binding that provides the array to render.
      * @param templateBinding - The template binding used to obtain a template to render for each item in the array.
      * @param options - Options used to turn on special repeat features.
      */
-    constructor(itemsBinding: Binding, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
+    constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
     /**
      * Creates a behavior for the provided target node.
      * @param target - The node instance to create the behavior for.
@@ -107,10 +103,10 @@ export declare class RepeatDirective<TSource = any> implements HTMLDirective, Vi
 }
 /**
  * A directive that enables list rendering.
- * @param itemsBinding - The array to render.
- * @param templateOrTemplateBinding - The template or a template binding used obtain a template
+ * @param items - The array to render.
+ * @param template - The template or a template binding used obtain a template
  * to render for each item in the array.
  * @param options - Options used to turn on special repeat features.
  * @public
  */
-export declare function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>>(itemsBinding: Binding<TSource, TArray, ExecutionContext<TSource>>, templateOrTemplateBinding: ViewTemplate | Binding<TSource, ViewTemplate>, options?: RepeatOptions): CaptureType<TSource>;
+export declare function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>>(items: Expression<TSource, TArray, ExecutionContext<TSource>> | Binding<TSource, TArray> | ReadonlyArray<any>, template: Expression<TSource, ViewTemplate> | Binding<TSource, ViewTemplate> | ViewTemplate, options?: RepeatOptions): CaptureType<TSource>;

package/dist/dts/templating/template.d.ts

@@ -1,5 +1,5 @@
-import { Binding, ExecutionContext } from "../observation/observable.js";
-import { HTMLDirective, ViewBehaviorFactory } from "./html-directive.js";
+import { ExecutionContext, Expression } from "../observation/observable.js";
+import { Binding, HTMLDirective, ViewBehaviorFactory } from "./html-directive.js";
 import type { ElementView, HTMLView, SyntheticView } from "./view.js";
 /**
  * A template capable of creating views specifically for rendering custom elements.
@@ -87,7 +87,7 @@ export interface CaptureType<TSource> {
  * Represents the types of values that can be interpolated into a template.
  * @public
  */
-export declare type TemplateValue<TSource, TParent = any> = Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource>;
+export declare type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource>;
 /**
  * Transforms a template literal string into a ViewTemplate.
  * @param strings - The string fragments that are interpolated with the values.

package/dist/dts/templating/when.d.ts

@@ -1,10 +1,10 @@
-import type { Binding } from "../observation/observable.js";
+import type { Expression } from "../observation/observable.js";
 import type { CaptureType, SyntheticViewTemplate } from "./template.js";
 /**
  * A directive that enables basic conditional rendering in a template.
- * @param binding - The condition to test for rendering.
+ * @param condition - The condition to test for rendering.
  * @param templateOrTemplateBinding - The template or a binding that gets
  * the template to render when the condition is true.
  * @public
  */
-export declare function when<TSource = any, TReturn = any>(binding: Binding<TSource, TReturn>, templateOrTemplateBinding: SyntheticViewTemplate | Binding<TSource, SyntheticViewTemplate>): CaptureType<TSource>;
+export declare function when<TSource = any, TReturn = any>(condition: Expression<TSource, TReturn> | boolean, templateOrTemplateBinding: SyntheticViewTemplate | Expression<TSource, SyntheticViewTemplate>): CaptureType<TSource>;

package/dist/dts/testing/exports.d.ts

@@ -0,0 +1,2 @@
+export { timeout } from "./timeout.js";
+export * from "./fixture.js";

package/dist/dts/testing/fixture.d.ts

@@ -0,0 +1,90 @@
+import type { Constructable } from "../interfaces.js";
+import { ExecutionContext } from "../observation/observable.js";
+import { ViewTemplate } from "../templating/template.js";
+import type { HTMLView } from "../templating/view.js";
+/**
+ * Options used to customize the creation of the test fixture.
+ * @public
+ */
+export interface FixtureOptions {
+    /**
+     * The document to run the fixture in.
+     * @defaultValue `globalThis.document`
+     */
+    document?: Document;
+    /**
+     * The parent element to append the fixture to.
+     * @defaultValue An instance of `HTMLDivElement`.
+     */
+    parent?: HTMLElement;
+    /**
+     * The data source to bind the HTML to.
+     * @defaultValue An empty object.
+     */
+    source?: any;
+    /**
+     * The execution context to use during binding.
+     * @defaultValue {@link @microsoft/fast-element#ExecutionContext}
+     */
+    context?: ExecutionContext;
+}
+/**
+ * A test fixture.
+ * @public
+ */
+export interface Fixture<TElement = HTMLElement> {
+    /**
+     * The document the fixture is running in.
+     */
+    document: Document;
+    /**
+     * The template the fixture was created from.
+     */
+    template: ViewTemplate;
+    /**
+     * The view that was created from the fixture's template.
+     */
+    view: HTMLView;
+    /**
+     * The parent element that the view was appended to.
+     * @remarks
+     * This element will be appended to the DOM only
+     * after {@link Fixture.connect} has been called.
+     */
+    parent: HTMLElement;
+    /**
+     * The first element in the {@link Fixture.view}.
+     */
+    element: TElement;
+    /**
+     * Adds the {@link Fixture.parent} to the DOM, causing the
+     * connect lifecycle to begin.
+     * @remarks
+     * Yields control to the caller one Microtask later, in order to
+     * ensure that the DOM has settled.
+     */
+    connect: () => Promise<void>;
+    /**
+     * Removes the {@link Fixture.parent} from the DOM, causing the
+     * disconnect lifecycle to begin.
+     * @remarks
+     * Yields control to the caller one Microtask later, in order to
+     * ensure that the DOM has settled.
+     */
+    disconnect: () => Promise<void>;
+}
+/**
+ * Creates a random, unique name suitable for use as a Custom Element name.
+ * @public
+ */
+export declare function uniqueElementName(prefix?: string): string;
+/**
+ * Creates a test fixture suitable for testing custom elements, templates, and bindings.
+ * @param templateNameOrType An HTML template or single element name to create the fixture for.
+ * @param options Enables customizing fixture creation behavior.
+ * @remarks
+ * Yields control to the caller one Microtask later, in order to
+ * ensure that the DOM has settled.
+ * @public
+ */
+export declare function fixture<TElement = HTMLElement>(templateNameOrType: ViewTemplate | string | Constructable<TElement>, options?: FixtureOptions): Promise<Fixture<TElement>>;

package/dist/dts/testing/timeout.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A timeout helper for use in tests.
+ * @param timeout The length of the timeout.
+ * @returns A promise that resolves once the configured time has elapsed.
+ * @public
+ */
+export declare function timeout(timeout?: number): Promise<void>;

package/dist/esm/components/fast-definitions.js

@@ -11,19 +11,15 @@ const fastElementRegistry = FAST.getById(4 /* KernelServiceId.elementRegistry */
  * @public
  */
 export class FASTElementDefinition {
-    /**
-     * Creates an instance of FASTElementDefinition.
-     * @param type - The type this definition is being created for.
-     * @param nameOrConfig - The name of the element to define or a config object
-     * that describes the element to define.
-     */
     constructor(type, nameOrConfig = type.definition) {
+        this.platformDefined = false;
         if (isString(nameOrConfig)) {
             nameOrConfig = { name: nameOrConfig };
         }
         this.type = type;
         this.name = nameOrConfig.name;
         this.template = nameOrConfig.template;
+        const proto = type.prototype;
         const attributes = AttributeDefinition.collect(type, nameOrConfig.attributes);
         const observedAttributes = new Array(attributes.length);
         const propertyLookup = {};
@@ -33,9 +29,13 @@ export class FASTElementDefinition {
             observedAttributes[i] = current.attribute;
             propertyLookup[current.name] = current;
             attributeLookup[current.attribute] = current;
+            Observable.defineProperty(proto, current);
         }
+        Reflect.defineProperty(type, "observedAttributes", {
+            value: observedAttributes,
+            enumerable: true,
+        });
         this.attributes = attributes;
-        this.observedAttributes = observedAttributes;
         this.propertyLookup = propertyLookup;
         this.attributeLookup = attributeLookup;
         this.shadowOptions =
@@ -48,20 +48,14 @@ export class FASTElementDefinition {
             nameOrConfig.elementOptions === void 0
                 ? defaultElementOptions
                 : Object.assign(Object.assign({}, defaultElementOptions), nameOrConfig.elementOptions);
-        this.styles =
-            nameOrConfig.styles === void 0
-                ? void 0
-                : Array.isArray(nameOrConfig.styles)
-                    ? new ElementStyles(nameOrConfig.styles)
-                    : nameOrConfig.styles instanceof ElementStyles
-                        ? nameOrConfig.styles
-                        : new ElementStyles([nameOrConfig.styles]);
+        this.styles = ElementStyles.normalize(nameOrConfig.styles);
+        fastElementRegistry.register(this);
     }
     /**
      * Indicates if this element has been defined in at least one registry.
      */
     get isDefined() {
-        return !!fastElementRegistry.getByType(this.type);
+        return this.platformDefined;
     }
     /**
      * Defines a custom element based on this definition.
@@ -71,22 +65,26 @@ export class FASTElementDefinition {
      */
     define(registry = customElements) {
         const type = this.type;
-        if (fastElementRegistry.register(this)) {
-            const attributes = this.attributes;
-            const proto = type.prototype;
-            for (let i = 0, ii = attributes.length; i < ii; ++i) {
-                Observable.defineProperty(proto, attributes[i]);
-            }
-            Reflect.defineProperty(type, "observedAttributes", {
-                value: this.observedAttributes,
-                enumerable: true,
-            });
-        }
         if (!registry.get(this.name)) {
+            this.platformDefined = true;
             registry.define(this.name, type, this.elementOptions);
         }
         return this;
     }
+    /**
+     * Creates an instance of FASTElementDefinition.
+     * @param type - The type this definition is being created for.
+     * @param nameOrDef - The name of the element to define or a config object
+     * that describes the element to define.
+     */
+    static compose(type, nameOrDef) {
+        const found = fastElementRegistry.getByType(type);
+        if (found) {
+            return new FASTElementDefinition(class extends type {
+            }, nameOrDef);
+        }
+        return new FASTElementDefinition(type, nameOrDef);
+    }
 }
 /**
  * Gets the element definition associated with the specified type.

package/dist/esm/components/fast-element.js

@@ -1,3 +1,4 @@
+import { isFunction } from "../interfaces.js";
 import { Controller } from "./controller.js";
 import { FASTElementDefinition, } from "./fast-definitions.js";
 /* eslint-disable-next-line @typescript-eslint/explicit-function-return-type */
@@ -22,6 +23,21 @@ function createFASTElement(BaseType) {
         }
     };
 }
+function compose(type, nameOrDef) {
+    if (isFunction(type)) {
+        return FASTElementDefinition.compose(type, nameOrDef);
+    }
+    return FASTElementDefinition.compose(this, type);
+}
+function define(type, nameOrDef) {
+    if (isFunction(type)) {
+        return FASTElementDefinition.compose(type, nameOrDef).define().type;
+    }
+    return FASTElementDefinition.compose(this, type).define().type;
+}
+function from(BaseType) {
+    return createFASTElement(BaseType);
+}
 /**
  * A minimal base class for FASTElements that also provides
  * static helpers for working with FASTElements.
@@ -33,26 +49,19 @@ export const FASTElement = Object.assign(createFASTElement(HTMLElement), {
      * provided base type.
      * @param BaseType - The base element type to inherit from.
      */
-    from(BaseType) {
-        return createFASTElement(BaseType);
-    },
+    from,
     /**
      * Defines a platform custom element based on the provided type and definition.
      * @param type - The custom element type to define.
      * @param nameOrDef - The name of the element to define or a definition object
      * that describes the element to define.
      */
-    define(type, nameOrDef) {
-        return this.metadata(type, nameOrDef).define().type;
-    },
+    define,
     /**
      * Defines metadata for a FASTElement which can be used to later define the element.
-     * IMPORTANT: This API will be renamed to "compose" in a future beta.
      * @public
      */
-    metadata(type, nameOrDef) {
-        return new FASTElementDefinition(type, nameOrDef);
-    },
+    compose,
 });
 /**
  * Decorator: Defines a platform custom element based on `FASTElement`.
@@ -63,6 +72,6 @@ export const FASTElement = Object.assign(createFASTElement(HTMLElement), {
 export function customElement(nameOrDef) {
     /* eslint-disable-next-line @typescript-eslint/explicit-function-return-type */
     return function (type) {
-        FASTElement.define(type, nameOrDef);
+        define(type, nameOrDef);
     };
 }