@microsoft/fast-element 1.10.5 → 2.0.0-beta.10

package/dist/dts/styles/css.d.ts

@@ -6,13 +6,29 @@ import { ComposableStyles, ElementStyles } from "./element-styles.js";
  * @param values - The values that are interpolated with the string fragments.
  * @remarks
  * The css helper supports interpolation of strings and ElementStyle instances.
+ * Use the .partial method to create partial CSS fragments.
  * @public
  */
-export declare function css(strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]): ElementStyles;
+export declare type CSSTemplateTag = ((strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]) => ElementStyles) & {
+    /**
+     * Transforms a template literal string into partial CSS.
+     * @param strings - The string fragments that are interpolated with the values.
+     * @param values - The values that are interpolated with the string fragments.
+     * @public
+     */
+    partial(strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]): CSSDirective;
+};
 /**
- * Transforms a template literal string into partial CSS.
+ * Transforms a template literal string into styles.
  * @param strings - The string fragments that are interpolated with the values.
  * @param values - The values that are interpolated with the string fragments.
+ * @remarks
+ * The css helper supports interpolation of strings and ElementStyle instances.
+ * @public
+ */
+export declare const css: CSSTemplateTag;
+/**
+ * @deprecated Use css.partial instead.
  * @public
  */
-export declare function cssPartial(strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]): CSSDirective;
+export declare const cssPartial: (strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]) => CSSDirective;

package/dist/dts/styles/element-styles.d.ts

@@ -1,55 +1,42 @@
-import type { Behavior } from "../observation/behavior.js";
-/**
- * A node that can be targeted by styles.
- * @public
- */
-export interface StyleTarget {
-    /**
-     * Stylesheets to be adopted by the node.
-     */
-    adoptedStyleSheets?: CSSStyleSheet[];
-    /**
-     * Adds styles to the target by appending the styles.
-     * @param styles - The styles element to add.
-     */
-    append(styles: HTMLStyleElement): void;
-    /**
-     * Adds styles to the target by prepending the styles.
-     * @param styles - The styles element to add.
-     * @deprecated - use append()
-     */
-    prepend(styles: HTMLStyleElement): void;
-    /**
-     * Removes styles from the target.
-     * @param styles - The styles element to remove.
-     */
-    removeChild(styles: HTMLStyleElement): void;
-    /**
-     * Returns all element descendants of node that match selectors.
-     * @param selectors - The CSS selector to use for the query.
-     */
-    querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
-}
+import { StyleStrategy, StyleTarget } from "../interfaces.js";
+import type { HostBehavior } from "./host.js";
 /**
  * Represents styles that can be composed into the ShadowDOM of a custom element.
  * @public
  */
 export declare type ComposableStyles = string | ElementStyles | CSSStyleSheet;
 /**
- * Creates an ElementStyles instance for an array of ComposableStyles.
+ * A type that instantiates a StyleStrategy.
  * @public
  */
-export declare type ElementStyleFactory = (styles: ReadonlyArray<ComposableStyles>) => ElementStyles;
+export declare type ConstructibleStyleStrategy = {
+    /**
+     * Creates an instance of the strategy.
+     * @param styles - The styles to initialize the strategy with.
+     */
+    new (styles: (string | CSSStyleSheet)[]): StyleStrategy;
+};
 /**
  * Represents styles that can be applied to a custom element.
  * @public
  */
-export declare abstract class ElementStyles {
+export declare class ElementStyles {
+    readonly styles: ReadonlyArray<ComposableStyles>;
     private targets;
-    /** @internal */
-    abstract readonly styles: ReadonlyArray<ComposableStyles>;
-    /** @internal */
-    abstract readonly behaviors: ReadonlyArray<Behavior> | null;
+    private _strategy;
+    /**
+     * The behaviors associated with this set of styles.
+     */
+    readonly behaviors: ReadonlyArray<HostBehavior<HTMLElement>> | null;
+    /**
+     * Gets the StyleStrategy associated with these element styles.
+     */
+    get strategy(): StyleStrategy;
+    /**
+     * Creates an instance of ElementStyles.
+     * @param styles - The styles that will be associated with elements.
+     */
+    constructor(styles: ReadonlyArray<ComposableStyles>);
     /** @internal */
     addStylesTo(target: StyleTarget): void;
     /** @internal */
@@ -60,11 +47,27 @@ export declare abstract class ElementStyles {
      * Associates behaviors with this set of styles.
      * @param behaviors - The behaviors to associate.
      */
-    withBehaviors(...behaviors: Behavior[]): this;
+    withBehaviors(...behaviors: HostBehavior<HTMLElement>[]): this;
     /**
-     * Create ElementStyles from ComposableStyles.
+     * Sets the strategy that handles adding/removing these styles for an element.
+     * @param strategy - The strategy to use.
      */
-    static readonly create: ElementStyleFactory;
+    withStrategy(Strategy: ConstructibleStyleStrategy): this;
+    /**
+     * Sets the default strategy type to use when creating style strategies.
+     * @param Strategy - The strategy type to construct.
+     */
+    static setDefaultStrategy(Strategy: ConstructibleStyleStrategy): void;
+    /**
+     * Normalizes a set of composable style options.
+     * @param styles - The style options to normalize.
+     * @returns A singular ElementStyles instance or undefined.
+     */
+    static normalize(styles: ComposableStyles | ComposableStyles[] | undefined): ElementStyles | undefined;
+    /**
+     * Indicates whether the DOM supports the adoptedStyleSheets feature.
+     */
+    static readonly supportsAdoptedStyleSheets: boolean;
 }
 /**
  * https://wicg.github.io/construct-stylesheets/
@@ -72,27 +75,10 @@ export declare abstract class ElementStyles {
  *
  * @internal
  */
-export declare class AdoptedStyleSheetsStyles extends ElementStyles {
-    styles: ComposableStyles[];
-    private styleSheetCache;
-    private _styleSheets;
-    private get styleSheets();
-    readonly behaviors: ReadonlyArray<Behavior> | null;
-    constructor(styles: ComposableStyles[], styleSheetCache: Map<string, CSSStyleSheet>);
-    addStylesTo(target: StyleTarget): void;
-    removeStylesFrom(target: StyleTarget): void;
-}
-/**
- * @internal
- */
-export declare class StyleElementStyles extends ElementStyles {
-    styles: ComposableStyles[];
-    private readonly styleSheets;
-    private readonly styleClass;
-    readonly behaviors: ReadonlyArray<Behavior> | null;
-    constructor(styles: ComposableStyles[]);
+export declare class AdoptedStyleSheetsStrategy implements StyleStrategy {
+    /** @internal */
+    readonly sheets: CSSStyleSheet[];
+    constructor(styles: (string | CSSStyleSheet)[]);
     addStylesTo(target: StyleTarget): void;
     removeStylesFrom(target: StyleTarget): void;
-    isAttachedTo(target: StyleTarget): boolean;
-    private normalizeTarget;
 }

package/dist/dts/styles/host.d.ts

@@ -0,0 +1,68 @@
+import type { ElementStyles } from "./element-styles.js";
+/**
+ * Controls the lifecycle and context of behaviors and styles
+ * associated with a component host.
+ * @public
+ */
+export interface HostController<TSource = any> {
+    /**
+     * The component source.
+     */
+    readonly source: TSource;
+    /**
+     * Indicates whether the host is connected or not.
+     */
+    readonly isConnected: boolean;
+    /**
+     * The main set of styles used for the component, independent
+     * of any behavior-specific styles.
+     */
+    mainStyles: ElementStyles | null;
+    /**
+     * Adds the behavior to the component.
+     * @param behavior - The behavior to add.
+     */
+    addBehavior(behavior: HostBehavior<TSource>): 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<TSource>, 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.
+     */
+    addStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
+    /**
+     * Removes styles from this element. Providing an HTMLStyleElement will detach the element instance from the shadowRoot.
+     * @param styles - the styles to remove.
+     */
+    removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
+}
+/**
+ * Represents an object that can contribute behavior to a host.
+ * @public
+ */
+export interface HostBehavior<TSource = any> {
+    /**
+     * Executed when this behavior is attached to a controller.
+     * @param controller - Controls the behavior lifecycle.
+     */
+    addedCallback?(controller: HostController<TSource>): void;
+    /**
+     * Executed when this behavior is detached from a controller.
+     * @param controller - Controls the behavior lifecycle.
+     */
+    removedCallback?(controller: HostController<TSource>): void;
+    /**
+     * Executed when this behavior's host is connected.
+     * @param controller - Controls the behavior lifecycle.
+     */
+    connectedCallback?(controller: HostController<TSource>): void;
+    /**
+     * Executed when this behavior's host is disconnected.
+     * @param controller - Controls the behavior lifecycle.
+     */
+    disconnectedCallback?(controller: HostController<TSource>): void;
+}

package/dist/dts/templating/binding-signal.d.ts

@@ -0,0 +1,21 @@
+import type { Expression } from "../observation/observable.js";
+import type { Subscriber } from "../observation/notifier.js";
+import { Binding } from "./html-directive.js";
+export declare const Signal: Readonly<{
+    subscribe(signal: string, subscriber: Subscriber): void;
+    unsubscribe(signal: string, subscriber: Subscriber): void;
+    /**
+     * Sends the specified signal to signaled bindings.
+     * @param signal - The signal to send.
+     * @public
+     */
+    send(signal: string): void;
+}>;
+/**
+ * Creates a signal binding configuration with the supplied options.
+ * @param expression - The binding to refresh when signaled.
+ * @param options - The signal name or a binding to use to retrieve the signal name.
+ * @returns A binding configuration.
+ * @public
+ */
+export declare function signal<T = any>(expression: Expression<T>, options: string | Expression<T>): Binding<T>;

package/dist/dts/templating/binding-two-way.d.ts

@@ -0,0 +1,39 @@
+import { Expression } from "../observation/observable.js";
+import type { HTMLBindingDirective } from "./binding.js";
+import { Binding } from "./html-directive.js";
+/**
+ * The twoWay binding options.
+ * @public
+ */
+export declare type TwoWayBindingOptions = {
+    changeEvent?: string;
+    fromView?: (value: any) => any;
+};
+/**
+ * The settings required to enable two-way binding.
+ * @public
+ */
+export interface TwoWaySettings {
+    /**
+     * Determines which event to listen to, to detect changes in the view.
+     * @param directive - The directive to determine the change event for.
+     * @param target - The target element to determine the change event for.
+     */
+    determineChangeEvent(directive: HTMLBindingDirective, target: HTMLElement): string;
+}
+export declare const TwoWaySettings: Readonly<{
+    /**
+     * Configures two-way binding.
+     * @param settings - The settings to use for the two-way binding system.
+     */
+    configure(settings: TwoWaySettings): void;
+}>;
+/**
+ * Creates a default binding.
+ * @param expression - The binding to refresh when changed.
+ * @param optionsOrChangeEvent - The binding options or the name of the change event to use.
+ * @param isBindingVolatile - Indicates whether the binding is volatile or not.
+ * @returns A binding.
+ * @public
+ */
+export declare function twoWay<T = any>(expression: Expression<T>, optionsOrChangeEvent?: TwoWayBindingOptions | string, isBindingVolatile?: boolean): Binding<T>;

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

@@ -1,95 +1,126 @@
-import type { Behavior } from "../observation/behavior.js";
-import { Binding, BindingObserver, ExecutionContext } from "../observation/observable.js";
-import { TargetedHTMLDirective } from "./html-directive.js";
-declare function normalBind(this: BindingBehavior, source: unknown, context: ExecutionContext): void;
-declare function normalUnbind(this: BindingBehavior): void;
-declare function updatePropertyTarget(this: BindingBehavior, value: unknown): void;
+import { ExecutionContext, Expression, ExpressionObserver } from "../observation/observable.js";
+import { AddViewBehaviorFactory, Aspect, Aspected, Binding, HTMLDirective, ViewBehavior, ViewBehaviorFactory, ViewController } from "./html-directive.js";
 /**
- * A directive that configures data binding to element content and attributes.
+ * A simple View that can be interpolated into HTML content.
  * @public
  */
-export declare class HTMLBindingDirective extends TargetedHTMLDirective {
-    binding: Binding;
-    private cleanedTargetName?;
-    private originalTargetName?;
-    private bind;
-    private unbind;
-    private updateTarget;
-    private isBindingVolatile;
+export interface ContentView {
+    readonly context: ExecutionContext;
     /**
-     * Creates an instance of BindingDirective.
-     * @param binding - A binding that returns the data used to update the DOM.
+     * Binds a view's behaviors to its binding source.
+     * @param source - The binding source for the view's binding behaviors.
+     * @param context - The execution context to run the view within.
      */
-    constructor(binding: Binding);
+    bind(source: any, context?: ExecutionContext): void;
     /**
-     * Gets/sets the name of the attribute or property that this
-     * binding is targeting.
+     * Unbinds a view's behaviors from its binding source and context.
      */
-    get targetName(): string | undefined;
-    set targetName(value: string | undefined);
+    unbind(): void;
     /**
-     * Makes this binding target the content of an element rather than
-     * a particular attribute or property.
+     * Inserts the view's DOM nodes before the referenced node.
+     * @param node - The node to insert the view's DOM before.
      */
-    targetAtContent(): void;
+    insertBefore(node: Node): void;
     /**
-     * Creates the runtime BindingBehavior instance based on the configuration
-     * information stored in the BindingDirective.
-     * @param target - The target node that the binding behavior should attach to.
+     * Removes the view's DOM nodes.
+     * The nodes are not disposed and the view can later be re-inserted.
      */
-    createBehavior(target: Node): BindingBehavior;
+    remove(): void;
 }
 /**
- * A behavior that updates content and attributes based on a configured
- * BindingDirective.
+ * A simple template that can create ContentView instances.
  * @public
  */
-export declare class BindingBehavior implements Behavior {
-    /** @internal */
-    source: unknown;
-    /** @internal */
-    context: ExecutionContext | null;
-    /** @internal */
-    bindingObserver: BindingObserver | null;
-    /** @internal */
-    classVersions: Record<string, number>;
-    /** @internal */
-    version: number;
-    /** @internal */
-    target: any;
-    /** @internal */
-    binding: Binding;
-    /** @internal */
-    isBindingVolatile: boolean;
-    /** @internal */
-    updateTarget: typeof updatePropertyTarget;
-    /** @internal */
-    targetName?: string;
+export interface ContentTemplate {
     /**
-     * Bind this behavior to the source.
-     * @param source - The source to bind to.
-     * @param context - The execution context that the binding is operating within.
+     * Creates a simple content view instance.
      */
-    bind: typeof normalBind;
+    create(): ContentView;
+}
+/**
+ * A directive that applies bindings.
+ * @public
+ */
+export declare class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, ViewBehavior, Aspected {
+    dataBinding: Binding;
+    private data;
+    private updateTarget;
+    /**
+     * The unique id of the factory.
+     */
+    id: string;
     /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
+     * The structural id of the DOM node to which the created behavior will apply.
      */
-    unbind: typeof normalUnbind;
+    nodeId: string;
     /**
-     * Creates an instance of BindingBehavior.
-     * @param target - The target of the data updates.
-     * @param binding - The binding that returns the latest value for an update.
-     * @param isBindingVolatile - Indicates whether the binding has volatile dependencies.
-     * @param bind - The operation to perform during binding.
-     * @param unbind - The operation to perform during unbinding.
-     * @param updateTarget - The operation to perform when updating.
-     * @param targetName - The name of the target attribute or property to update.
+     * The original source aspect exactly as represented in markup.
      */
-    constructor(target: any, binding: Binding, isBindingVolatile: boolean, bind: typeof normalBind, unbind: typeof normalUnbind, updateTarget: typeof updatePropertyTarget, targetName?: string);
+    sourceAspect: string;
+    /**
+     * The evaluated target aspect, determined after processing the source.
+     */
+    targetAspect: string;
+    /**
+     * The type of aspect to target.
+     */
+    aspectType: Aspect;
+    /**
+     * Creates an instance of HTMLBindingDirective.
+     * @param dataBinding - The binding configuration to apply.
+     */
+    constructor(dataBinding: Binding);
+    /**
+     * 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.
+     */
+    createBehavior(): ViewBehavior;
+    /** @internal */
+    bindDefault(controller: ViewController): void;
     /** @internal */
-    handleChange(): void;
+    bind: (controller: ViewController) => void;
+    /** @internal */
+    bindContent(controller: ViewController): void;
+    /** @internal */
+    bindEvent(controller: ViewController): void;
+    /** @internal */
+    unbind(controller: ViewController): void;
     /** @internal */
     handleEvent(event: Event): void;
+    /** @internal */
+    handleChange(binding: Expression, observer: ExpressionObserver): void;
 }
-export {};
+/**
+ * Creates an standard binding.
+ * @param binding - The binding to refresh when changed.
+ * @param isVolatile - Indicates whether the binding is volatile or not.
+ * @returns A binding configuration.
+ * @public
+ */
+export declare function bind<T = any>(binding: Expression<T>, isVolatile?: boolean): Binding<T>;
+/**
+ * Creates a one time binding
+ * @param binding - The binding to refresh when signaled.
+ * @returns A binding configuration.
+ * @public
+ */
+export declare function oneTime<T = any>(binding: Expression<T>): Binding<T>;
+/**
+ * Creates an event listener binding.
+ * @param binding - The binding to invoke when the event is raised.
+ * @param options - Event listener options.
+ * @returns A binding configuration.
+ * @public
+ */
+export declare function listener<T = any>(binding: Expression<T>, options?: AddEventListenerOptions): Binding<T>;
+/**
+ * Normalizes the input value into a binding.
+ * @param value - The value to create the default binding for.
+ * @returns A binding configuration for the provided value.
+ * @public
+ */
+export declare function normalizeBinding<TSource = any, TReturn = any, TParent = any>(value: Expression<TSource, TReturn, TParent> | Binding<TSource, TReturn, TParent> | {}): Binding<TSource, TReturn, TParent>;

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

@@ -1,16 +1,16 @@
-import { NodeBehaviorOptions, NodeObservationBehavior } from "./node-observation.js";
+import { NodeBehaviorOptions, NodeObservationDirective } from "./node-observation.js";
 import type { CaptureType } from "./template.js";
 /**
  * The options used to configure child list observation.
  * @public
  */
-export interface ChildListBehaviorOptions<T = any> extends NodeBehaviorOptions<T>, Omit<MutationObserverInit, "subtree" | "childList"> {
+export interface ChildListDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, Omit<MutationObserverInit, "subtree" | "childList"> {
 }
 /**
  * The options used to configure subtree observation.
  * @public
  */
-export interface SubtreeBehaviorOptions<T = any> extends Omit<NodeBehaviorOptions<T>, "filter">, Omit<MutationObserverInit, "subtree" | "childList"> {
+export interface SubtreeDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, Omit<MutationObserverInit, "subtree" | "childList"> {
     /**
      * Indicates that child subtrees should be observed for changes.
      */
@@ -25,31 +25,34 @@ export interface SubtreeBehaviorOptions<T = any> extends Omit<NodeBehaviorOption
  * The options used to configure child/subtree node observation.
  * @public
  */
-export declare type ChildrenBehaviorOptions<T = any> = ChildListBehaviorOptions<T> | SubtreeBehaviorOptions<T>;
+export declare type ChildrenDirectiveOptions<T = any> = ChildListDirectiveOptions<T> | SubtreeDirectiveOptions<T>;
 /**
  * The runtime behavior for child node observation.
  * @public
  */
-export declare class ChildrenBehavior extends NodeObservationBehavior<ChildrenBehaviorOptions> {
-    private observer;
+export declare class ChildrenDirective extends NodeObservationDirective<ChildrenDirectiveOptions> {
+    private observerProperty;
     /**
-     * Creates an instance of ChildrenBehavior.
-     * @param target - The element target to observe children on.
-     * @param options - The options to use when observing the element children.
+     * Creates an instance of ChildrenDirective.
+     * @param options - The options to use in configuring the child observation behavior.
      */
-    constructor(target: HTMLElement, options: ChildrenBehaviorOptions);
+    constructor(options: ChildrenDirectiveOptions);
     /**
      * Begins observation of the nodes.
+     * @param target - The target to observe.
      */
-    observe(): void;
+    observe(target: any): void;
     /**
      * Disconnects observation of the nodes.
+     * @param target - The target to unobserve.
      */
-    disconnect(): void;
+    disconnect(target: any): void;
     /**
-     * Retrieves the nodes that should be assigned to the target.
+     * Retrieves the raw nodes that should be assigned to the source property.
+     * @param target - The target to get the node to.
      */
-    protected getNodes(): ChildNode[];
+    getNodes(target: Element): Node[];
+    private handleEvent;
 }
 /**
  * A directive that observes the `childNodes` of an element and updates a property
@@ -57,4 +60,4 @@ export declare class ChildrenBehavior extends NodeObservationBehavior<ChildrenBe
  * @param propertyOrOptions - The options used to configure child node observation.
  * @public
  */
-export declare function children<T = any>(propertyOrOptions: (keyof T & string) | ChildrenBehaviorOptions<keyof T & string>): CaptureType<T>;
+export declare function children<TSource = any, TParent = any>(propertyOrOptions: (keyof TSource & string) | ChildrenDirectiveOptions<keyof TSource & string>): CaptureType<TSource, TParent>;

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

@@ -1,38 +1,56 @@
-import type { HTMLDirective, NodeBehaviorFactory } from "./html-directive.js";
+import { TrustedTypesPolicy } from "../interfaces.js";
+import { ViewBehaviorFactory } from "./html-directive.js";
+import type { HTMLTemplateCompilationResult as TemplateCompilationResult } from "./template.js";
 /**
- * The result of compiling a template and its directives.
- * @beta
+ * A function capable of compiling a template from the preprocessed form produced
+ * by the html template function into a result that can instantiate views.
+ * @public
+ */
+export declare type CompilationStrategy = (
+/**
+ * The preprocessed HTML string or template to compile.
  */
-export interface CompilationResult {
+html: string | HTMLTemplateElement, 
+/**
+ * The behavior factories used within the html that is being compiled.
+ */
+factories: Record<string, ViewBehaviorFactory>) => TemplateCompilationResult;
+/**
+ * Common APIs related to compilation.
+ * @public
+ */
+export declare const Compiler: {
     /**
-     * A cloneable DocumentFragment representing the compiled HTML.
+     * Sets the HTML trusted types policy used by the compiler.
+     * @param policy - The policy to set for HTML.
+     * @remarks
+     * This API can only be called once, for security reasons. It should be
+     * called by the application developer at the start of their program.
      */
-    fragment: DocumentFragment;
+    setHTMLPolicy(policy: TrustedTypesPolicy): void;
     /**
-     * The behaviors that should be applied to the template's HTML.
+     * Compiles a template and associated directives into a compilation
+     * result which can be used to create views.
+     * @param html - The html string or template element to compile.
+     * @param directives - The directives referenced by the template.
+     * @remarks
+     * The template that is provided for compilation is altered in-place
+     * and cannot be compiled again. If the original template must be preserved,
+     * it is recommended that you clone the original and pass the clone to this API.
+     * @public
      */
-    viewBehaviorFactories: NodeBehaviorFactory[];
+    compile<TSource = any, TParent = any>(html: string | HTMLTemplateElement, directives: Record<string, ViewBehaviorFactory>): TemplateCompilationResult<TSource, TParent>;
     /**
-     * The behaviors that should be applied to the host element that
-     * the template is rendered into.
+     * Sets the default compilation strategy that will be used by the ViewTemplate whenever
+     * it needs to compile a view preprocessed with the html template function.
+     * @param strategy - The compilation strategy to use when compiling templates.
      */
-    hostBehaviorFactories: NodeBehaviorFactory[];
+    setDefaultStrategy(strategy: CompilationStrategy): void;
     /**
-     * An index offset to apply to BehaviorFactory target indexes when
-     * matching factories to targets.
+     * Aggregates an array of strings and directives into a single directive.
+     * @param parts - A heterogeneous array of static strings interspersed with
+     * directives.
+     * @returns A single inline directive that aggregates the behavior of all the parts.
      */
-    targetOffset: number;
-}
-/**
- * Compiles a template and associated directives into a raw compilation
- * result which include a cloneable DocumentFragment and factories capable
- * of attaching runtime behavior to nodes within the fragment.
- * @param template - The template to compile.
- * @param directives - The directives referenced by the template.
- * @remarks
- * The template that is provided for compilation is altered in-place
- * and cannot be compiled again. If the original template must be preserved,
- * it is recommended that you clone the original and pass the clone to this API.
- * @public
- */
-export declare function compileTemplate(template: HTMLTemplateElement, directives: ReadonlyArray<HTMLDirective>): CompilationResult;
+    aggregate(parts: (string | ViewBehaviorFactory)[]): ViewBehaviorFactory;
+};