@microsoft/fast-element 2.10.4 → 3.0.0-rc.2

package/dist/dts/state/state.d.ts

@@ -39,7 +39,7 @@ export type State<T> = ReadonlyState<T> & {
     current: T;
     /**
      * Sets the current state value.
-     * @param value The new state value.
+     * @param value - The new state value.
      */
     set(value: T): void;
     /**
@@ -121,7 +121,7 @@ export type ComputedBuilder = {
     on: {
         /**
          * Provides a setup callback for the computation.
-         * @param callback The callback to run to setup the computation.
+         * @param callback - The callback to run to setup the computation.
          */
         setup(callback: ComputedSetupCallback): void;
     };

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

@@ -1,22 +1,16 @@
 import type { Constructable } from "../interfaces.js";
-import type { HostBehavior } from "./host.js";
 import type { ComposableStyles } from "./element-styles.js";
 /**
- * Used to add behaviors when constructing styles.
- * @public
- */
-export type AddBehavior = (behavior: HostBehavior<HTMLElement>) => void;
-/**
- * Directive for use in {@link css}.
+ * Directive for use in CSS templates.
  *
  * @public
  */
 export interface CSSDirective {
     /**
-     * Creates a CSS fragment to interpolate into the CSS document.
-     * @returns - the string to interpolate into CSS
+     * Creates static styles to interpolate into the CSS document.
+     * @returns - the styles to interpolate into CSS
      */
-    createCSS(add: AddBehavior): ComposableStyles;
+    createCSS(): ComposableStyles;
 }
 /**
  * Defines metadata for a CSSDirective.
@@ -29,8 +23,7 @@ export interface CSSDirectiveDefinition<TType extends Constructable<CSSDirective
     readonly type: TType;
 }
 /**
- * Instructs the css engine to provide dynamic styles or
- * associate behaviors with styles.
+ * Instructs the css engine to provide styles during CSS template composition.
  * @public
  */
 export declare const CSSDirective: Readonly<{

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

@@ -1,36 +1,34 @@
-import { Binding } from "../binding/binding.js";
-import type { Expression } from "../observation/observable.js";
 import { CSSDirective } from "./css-directive.js";
 import { type ComposableStyles, ElementStyles } from "./element-styles.js";
 /**
  * Represents the types of values that can be interpolated into a template.
  * @public
  */
-export type CSSValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | ComposableStyles | CSSDirective;
+export type CSSValue = ComposableStyles | CSSDirective;
 /**
  * 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.
+ * The css helper supports interpolation of static composable styles and CSS directives.
  * Use the .partial method to create partial CSS fragments.
  * @public
  */
-export type CSSTemplateTag = (<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: CSSValue<TSource, TParent>[]) => ElementStyles) & {
+export type CSSTemplateTag = ((strings: TemplateStringsArray, ...values: CSSValue[]) => 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<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: CSSValue<TSource, TParent>[]): CSSDirective;
+    partial(strings: TemplateStringsArray, ...values: CSSValue[]): CSSDirective;
 };
 /**
  * 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.
+ * The css helper supports interpolation of static composable styles and CSS directives.
  * @public
  */
 export declare const css: CSSTemplateTag;

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

@@ -1,5 +1,4 @@
 import type { StyleStrategy, StyleTarget } from "./style-strategy.js";
-import type { HostBehavior } from "./host.js";
 /**
  * Represents styles that can be composed into the ShadowDOM of a custom element.
  * @public
@@ -24,10 +23,6 @@ export declare class ElementStyles {
     readonly styles: ReadonlyArray<ComposableStyles>;
     private targets;
     private _strategy;
-    /**
-     * The behaviors associated with this set of styles.
-     */
-    readonly behaviors: ReadonlyArray<HostBehavior<HTMLElement>> | null;
     /**
      * Gets the StyleStrategy associated with these element styles.
      */
@@ -43,11 +38,6 @@ export declare class ElementStyles {
     removeStylesFrom(target: StyleTarget): void;
     /** @internal */
     isAttachedTo(target: StyleTarget): boolean;
-    /**
-     * Associates behaviors with this set of styles.
-     * @param behaviors - The behaviors to associate.
-     */
-    withBehaviors(...behaviors: HostBehavior<HTMLElement>[]): this;
     /**
      * Sets the strategy that handles adding/removing these styles for an element.
      * @param strategy - The strategy to use.

package/dist/dts/styles.d.ts

@@ -0,0 +1,6 @@
+export type { Constructable } from "./interfaces.js";
+export type { ExecutionContext, ExpressionController, SourceLifetime, } from "./observation/observable.js";
+export { CSSDirective, type CSSDirectiveDefinition, cssDirective, } from "./styles/css-directive.js";
+export { type ComposableStyles, type ConstructibleStyleStrategy, ElementStyles, } from "./styles/element-styles.js";
+export type { HostBehavior, HostController } from "./styles/host.js";
+export type { StyleStrategy, StyleTarget } from "./styles/style-strategy.js";

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

@@ -1,4 +1,4 @@
-import { type DOMPolicy } from "../dom.js";
+import type { DOMPolicy } from "../dom-policy.js";
 import { type ViewBehaviorFactory } from "./html-directive.js";
 import type { HTMLTemplateCompilationResult as TemplateCompilationResult } from "./template.js";
 /**

package/dist/dts/templating/html-binding-directive.d.ts

@@ -1,5 +1,6 @@
 import type { Binding, BindingDirective } from "../binding/binding.js";
-import { DOMAspect, type DOMPolicy } from "../dom.js";
+import { DOMAspect } from "../dom.js";
+import type { DOMPolicy } from "../dom-policy.js";
 import { ExecutionContext, type Expression, type ExpressionObserver } from "../observation/observable.js";
 import { type AddViewBehaviorFactory, type Aspected, HTMLDirective, type ViewBehavior, type ViewBehaviorFactory, type ViewController } from "./html-directive.js";
 /**
@@ -39,6 +40,10 @@ export interface ContentTemplate {
      */
     create(): ContentView;
 }
+/**
+ * A template capable of hydrating content from existing DOM nodes.
+ * @beta
+ */
 export interface HydratableContentTemplate extends ContentTemplate {
     /**
      * Hydrates a content view from first/last nodes.
@@ -61,7 +66,6 @@ export interface HydratableContentTemplate extends ContentTemplate {
  * @public
  */
 export declare class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, ViewBehavior, Aspected, BindingDirective {
-    dataBinding: Binding;
     private data;
     private updateTarget;
     /**
@@ -92,6 +96,10 @@ export declare class HTMLBindingDirective implements HTMLDirective, ViewBehavior
      * The type of aspect to target.
      */
     aspectType: DOMAspect;
+    /**
+     * The binding configuration to apply.
+     */
+    dataBinding: Binding;
     /**
      * Creates an instance of HTMLBindingDirective.
      * @param dataBinding - The binding configuration to apply.

package/dist/dts/templating/html-directive.d.ts

@@ -1,5 +1,6 @@
 import type { Binding } from "../binding/binding.js";
-import { DOMAspect, type DOMPolicy } from "../dom.js";
+import { DOMAspect } from "../dom.js";
+import type { DOMPolicy } from "../dom-policy.js";
 import type { Constructable } from "../interfaces.js";
 import type { ExpressionController } from "../observation/observable.js";
 /**
@@ -18,6 +19,23 @@ export interface ViewController<TSource = any, TParent = any> extends Expression
      * The parts of the view that are targeted by view behaviors.
      */
     readonly targets: ViewBehaviorTargets;
+    /**
+     * When true, directives skip attribute/booleanAttribute DOM
+     * updates during bind(). This is an internal flag set only
+     * during the prerendered bind window.
+     * @internal
+     */
+    readonly _skipAttrUpdates?: boolean;
+    /**
+     * Resolves `true` when the view's host element had prerendered
+     * content (existing shadow root).
+     */
+    readonly isPrerendered?: Promise<boolean>;
+    /**
+     * Resolves `true` after prerendered content has been hydrated,
+     * `false` when client-side rendered or hydration not enabled.
+     */
+    readonly isHydrated?: Promise<boolean>;
 }
 /**
  * Represents an object that can contribute behavior to a view.

package/dist/dts/templating/hydration-view.d.ts

@@ -0,0 +1,130 @@
+import { Hydratable } from "../components/hydration.js";
+import { type HydrationMismatchActual, type HydrationMismatchExpectation } from "../hydration/diagnostics.js";
+import { type ViewBehaviorBoundaries } from "../hydration/target-builder.js";
+import { type ExecutionContext, SourceLifetime } from "../observation/observable.js";
+import type { ViewTemplate } from "../templating/template.js";
+import type { ViewBehaviorFactory, ViewBehaviorTargets, ViewController } from "./html-directive.js";
+import { DefaultExecutionContext, type ElementView, type SyntheticView } from "./view.js";
+/** @public */
+export interface HydratableView<TSource = any, TParent = any> extends ElementView<TSource, TParent>, SyntheticView<TSource, TParent>, DefaultExecutionContext<TParent> {
+    [Hydratable]: symbol;
+    readonly bindingViewBoundaries: Record<string, ViewNodes>;
+    readonly hydrationStage: keyof typeof HydrationStage;
+}
+/**
+ * A view controller that can hydrate existing DOM nodes.
+ * @beta
+ */
+export type HydratableViewController<TSource = any, TParent = any> = HydratableView<TSource, TParent> & ViewController<TSource, TParent>;
+/** @public */
+export interface ViewNodes {
+    first: Node;
+    last: Node;
+}
+/** @public */
+export declare const HydrationStage: {
+    readonly unhydrated: "unhydrated";
+    readonly hydrating: "hydrating";
+    readonly hydrated: "hydrated";
+};
+/** @public */
+export declare class HydrationBindingError extends Error {
+    /**
+     * The factory that was unable to be bound
+     */
+    readonly factory: ViewBehaviorFactory;
+    /**
+     * A DocumentFragment containing a clone of the
+     * view's Nodes.
+     */
+    readonly fragment: DocumentFragment;
+    /**
+     * String representation of the HTML in the template that
+     * threw the binding error.
+     */
+    readonly templateString: string;
+    /**
+     * Structured description of the binding the hydration walk was
+     * attempting to apply when the mismatch was detected.
+     */
+    readonly expected?: HydrationMismatchExpectation | undefined;
+    /**
+     * Structured description of the server-rendered DOM that was
+     * encountered at the mismatch point.
+     */
+    readonly received?: HydrationMismatchActual | undefined;
+    constructor(
+    /**
+     * The error message
+     */
+    message: string | undefined, 
+    /**
+     * The factory that was unable to be bound
+     */
+    factory: ViewBehaviorFactory, 
+    /**
+     * A DocumentFragment containing a clone of the
+     * view's Nodes.
+     */
+    fragment: DocumentFragment, 
+    /**
+     * String representation of the HTML in the template that
+     * threw the binding error.
+     */
+    templateString: string, 
+    /**
+     * Structured description of the binding the hydration walk was
+     * attempting to apply when the mismatch was detected.
+     */
+    expected?: HydrationMismatchExpectation | undefined, 
+    /**
+     * Structured description of the server-rendered DOM that was
+     * encountered at the mismatch point.
+     */
+    received?: HydrationMismatchActual | undefined);
+}
+export declare class HydrationView<TSource = any, TParent = any> extends DefaultExecutionContext<TParent> implements HydratableView {
+    readonly firstChild: Node;
+    readonly lastChild: Node;
+    private sourceTemplate;
+    private hostBindingTarget?;
+    [Hydratable]: symbol;
+    context: ExecutionContext<any>;
+    source: TSource | null;
+    isBound: boolean;
+    get hydrationStage(): "hydrated" | "hydrating" | "unhydrated";
+    get targets(): ViewBehaviorTargets;
+    get bindingViewBoundaries(): ViewBehaviorBoundaries;
+    readonly sourceLifetime: SourceLifetime;
+    private unbindables;
+    private fragment;
+    private behaviors;
+    private factories;
+    private _hydrationStage;
+    private _bindingViewBoundaries;
+    private _targets;
+    constructor(firstChild: Node, lastChild: Node, sourceTemplate: ViewTemplate, hostBindingTarget?: Element | undefined);
+    /**
+     * no-op. Hydrated views are don't need to be moved from a documentFragment
+     * to the target node.
+     */
+    insertBefore(node: Node): void;
+    /**
+     * Appends the view to a node. In cases where this is called before the
+     * view has been removed, the method will no-op.
+     * @param node - the node to append the view to.
+     */
+    appendTo(node: Node): void;
+    remove(): void;
+    bind(source: TSource, context?: ExecutionContext<any>): void;
+    unbind(): void;
+    /**
+     * Removes the view and unbinds its behaviors, disposing of DOM nodes afterward.
+     * Once a view has been disposed, it cannot be inserted or bound again.
+     */
+    dispose(): void;
+    onUnbind(behavior: {
+        unbind(controller: ViewController<TSource, TParent>): void;
+    }): void;
+    private evaluateUnbindables;
+}

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

@@ -1,6 +1,6 @@
 import { Binding, type BindingDirective } from "../binding/binding.js";
 import type { FASTElement } from "../components/fast-element.js";
-import type { DOMPolicy } from "../dom.js";
+import type { DOMPolicy } from "../dom-policy.js";
 import { type Constructable } from "../interfaces.js";
 import type { Subscriber } from "../observation/notifier.js";
 import type { ExecutionContext, Expression, ExpressionObserver } from "../observation/observable.js";

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

@@ -1,5 +1,5 @@
 import type { Binding, BindingDirective } from "../binding/binding.js";
-import { Sort, Splice } from "../observation/arrays.js";
+import { type Sort, type Splice } from "../observation/arrays.js";
 import type { Subscriber } from "../observation/notifier.js";
 import { type Expression, type ExpressionObserver } from "../observation/observable.js";
 import { type AddViewBehaviorFactory, HTMLDirective, type ViewBehavior, type ViewBehaviorFactory, type ViewController } from "./html-directive.js";

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

@@ -1,5 +1,5 @@
 import { Binding } from "../binding/binding.js";
-import type { DOMPolicy } from "../dom.js";
+import type { DOMPolicy } from "../dom-policy.js";
 import type { Expression } from "../observation/observable.js";
 import { type AddViewBehaviorFactory, type CompiledViewBehaviorFactory, HTMLDirective, type ViewBehaviorFactory } from "./html-directive.js";
 import type { ElementView, HTMLView, SyntheticView } from "./view.js";
@@ -22,6 +22,10 @@ export interface ElementViewTemplate<TSource = any, TParent = any> {
      */
     render(source: TSource, host: Node, hostBindingTarget?: Element): ElementView<TSource, TParent>;
 }
+/**
+ * A template capable of hydrating an element view from existing DOM nodes.
+ * @beta
+ */
 export interface HydratableElementViewTemplate<TSource = any, TParent = any> extends ElementViewTemplate<TSource, TParent> {
     hydrate(firstChild: Node, lastChild: Node, hostBindingTarget?: Element): ElementView<TSource, TParent>;
 }
@@ -30,7 +34,7 @@ export interface HydratableElementViewTemplate<TSource = any, TParent = any> ext
  * into templates.
  * @public
  */
-export interface CaptureType<TSource, TParent> {
+export interface CaptureType<TSource = any, TParent = any> {
 }
 /**
  * A template capable of rendering views not specifically connected to custom elements.
@@ -46,6 +50,10 @@ export interface SyntheticViewTemplate<TSource = any, TParent = any> {
      */
     inline(): CaptureType<TSource, TParent>;
 }
+/**
+ * A template capable of hydrating a synthetic view from existing DOM nodes.
+ * @beta
+ */
 export interface HydratableSyntheticViewTemplate<TSource = any, TParent = any> extends SyntheticViewTemplate {
     hydrate(firstChild: Node, lastChild: Node): SyntheticView<TSource, TParent>;
 }
@@ -115,11 +123,6 @@ export declare class ViewTemplate<TSource = any, TParent = any> implements Eleme
      * @internal
      */
     compile(): HTMLTemplateCompilationResult<TSource, TParent>;
-    /**
-     * Creates an HTMLView instance based on this template definition.
-     * @param hostBindingTarget - The element that host behaviors will be bound to.
-     */
-    create(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
     /**
      * Returns a directive that can inline the template.
      */
@@ -141,6 +144,11 @@ export declare class ViewTemplate<TSource = any, TParent = any> implements Eleme
      * host that the template is being attached to.
      */
     render(source: TSource, host: Node, hostBindingTarget?: Element): HTMLView<TSource, TParent>;
+    /**
+     * Creates an HTMLView instance based on this template definition.
+     * @param hostBindingTarget - The element that host behaviors will be bound to.
+     */
+    create(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
     /**
      * Processes the tagged template literal's static strings and interpolated values and
      * creates a ViewTemplate.

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

@@ -1,9 +1,6 @@
-import { Hydratable } from "../components/hydration.js";
-import { type ViewBehaviorBoundaries } from "../hydration/target-builder.js";
 import type { Disposable } from "../interfaces.js";
 import { ExecutionContext, SourceLifetime } from "../observation/observable.js";
-import type { ViewTemplate } from "../templating/template.js";
-import type { CompiledViewBehaviorFactory, ViewBehaviorFactory, ViewBehaviorTargets, ViewController } from "./html-directive.js";
+import type { CompiledViewBehaviorFactory, ViewBehaviorTargets, ViewController } from "./html-directive.js";
 /**
  * Represents a collection of DOM nodes which can be bound to a data source.
  * @public
@@ -77,7 +74,12 @@ export interface SyntheticView<TSource = any, TParent = any> extends View<TSourc
      */
     remove(): void;
 }
-declare class DefaultExecutionContext<TParent> implements ExecutionContext<TParent> {
+export declare function removeNodeSequence(firstNode: Node, lastNode: Node): void;
+/**
+ * The default execution context for template views.
+ * @public
+ */
+export declare class DefaultExecutionContext<TParent> implements ExecutionContext<TParent> {
     /**
      * The index of the current item within a repeat context.
      */
@@ -154,6 +156,24 @@ export declare class HTMLView<TSource = any, TParent = any> extends DefaultExecu
      * Indicates how the source's lifetime relates to the controller's lifetime.
      */
     readonly sourceLifetime: SourceLifetime;
+    /**
+     * When true, directives skip attribute/booleanAttribute DOM
+     * updates during bind(). Set only during the prerendered bind
+     * window and cleared immediately after.
+     * @internal
+     */
+    _skipAttrUpdates: boolean;
+    /**
+     * A promise that resolves with `true` after prerendered content
+     * has been hydrated, or `false` when the view is client-side
+     * rendered. Resolves once the first bind completes.
+     */
+    isPrerendered: Promise<boolean>;
+    /**
+     * Resolves `true` after prerendered content has been hydrated,
+     * `false` when client-side rendered or hydration not enabled.
+     */
+    isHydrated: Promise<boolean>;
     /**
      * The execution context the view is running within.
      */
@@ -223,100 +243,3 @@ export declare class HTMLView<TSource = any, TParent = any> extends DefaultExecu
      */
     static disposeContiguousBatch(views: SyntheticView[]): void;
 }
-/** @public */
-export interface HydratableView<TSource = any, TParent = any> extends ElementView, SyntheticView, DefaultExecutionContext<TParent> {
-    [Hydratable]: symbol;
-    readonly bindingViewBoundaries: Record<string, ViewNodes>;
-    readonly hydrationStage: keyof typeof HydrationStage;
-}
-export interface ViewNodes {
-    first: Node;
-    last: Node;
-}
-export declare const HydrationStage: {
-    readonly unhydrated: "unhydrated";
-    readonly hydrating: "hydrating";
-    readonly hydrated: "hydrated";
-};
-/** @public */
-export declare class HydrationBindingError extends Error {
-    /**
-     * The factory that was unable to be bound
-     */
-    readonly factory: ViewBehaviorFactory;
-    /**
-     * A DocumentFragment containing a clone of the
-     * view's Nodes.
-     */
-    readonly fragment: DocumentFragment;
-    /**
-     * String representation of the HTML in the template that
-     * threw the binding error.
-     */
-    readonly templateString: string;
-    constructor(
-    /**
-     * The error message
-     */
-    message: string | undefined, 
-    /**
-     * The factory that was unable to be bound
-     */
-    factory: ViewBehaviorFactory, 
-    /**
-     * A DocumentFragment containing a clone of the
-     * view's Nodes.
-     */
-    fragment: DocumentFragment, 
-    /**
-     * String representation of the HTML in the template that
-     * threw the binding error.
-     */
-    templateString: string);
-}
-export declare class HydrationView<TSource = any, TParent = any> extends DefaultExecutionContext<TParent> implements HydratableView {
-    readonly firstChild: Node;
-    readonly lastChild: Node;
-    private sourceTemplate;
-    private hostBindingTarget?;
-    [Hydratable]: symbol;
-    context: ExecutionContext<any>;
-    source: TSource | null;
-    isBound: boolean;
-    get hydrationStage(): "unhydrated" | "hydrating" | "hydrated";
-    get targets(): ViewBehaviorTargets;
-    get bindingViewBoundaries(): ViewBehaviorBoundaries;
-    readonly sourceLifetime: SourceLifetime;
-    private unbindables;
-    private fragment;
-    private behaviors;
-    private factories;
-    private _hydrationStage;
-    private _bindingViewBoundaries;
-    private _targets;
-    constructor(firstChild: Node, lastChild: Node, sourceTemplate: ViewTemplate, hostBindingTarget?: Element | undefined);
-    /**
-     * no-op. Hydrated views are don't need to be moved from a documentFragment
-     * to the target node.
-     */
-    insertBefore(node: Node): void;
-    /**
-     * Appends the view to a node. In cases where this is called before the
-     * view has been removed, the method will no-op.
-     * @param node - the node to append the view to.
-     */
-    appendTo(node: Node): void;
-    remove(): void;
-    bind(source: TSource, context?: ExecutionContext<any>): void;
-    unbind(): void;
-    /**
-     * Removes the view and unbinds its behaviors, disposing of DOM nodes afterward.
-     * Once a view has been disposed, it cannot be inserted or bound again.
-     */
-    dispose(): void;
-    onUnbind(behavior: {
-        unbind(controller: ViewController<TSource, TParent>): void;
-    }): void;
-    private evaluateUnbindables;
-}
-export {};

package/dist/dts/templating.d.ts

@@ -0,0 +1,10 @@
+export type { Binding, BindingDirective } from "./binding/binding.js";
+export type { DOMAspect, DOMPolicy } from "./dom.js";
+export type { ExecutionContext, ExpressionController, SourceLifetime, } from "./observation/observable.js";
+export { type CompilationStrategy, Compiler } from "./templating/compiler.js";
+export { type ContentTemplate, type ContentView, HTMLBindingDirective, } from "./templating/html-binding-directive.js";
+export { type AddViewBehaviorFactory, type Aspected, type CompiledViewBehaviorFactory, HTMLDirective, type HTMLDirectiveDefinition, htmlDirective, type PartialHTMLDirectiveDefinition, StatelessAttachedAttributeDirective, type ViewBehavior, type ViewBehaviorFactory, type ViewBehaviorTargets, type ViewController, } from "./templating/html-directive.js";
+export { Markup, Parser } from "./templating/markup.js";
+export { RenderBehavior, RenderDirective, render } from "./templating/render.js";
+export { type CaptureType, type ElementViewTemplate, type HTMLTemplateCompilationResult, type HTMLTemplateTag, InlineTemplateDirective, type SyntheticViewTemplate, type TemplateValue, ViewTemplate, } from "./templating/template.js";
+export { type ElementView, HTMLView, type SyntheticView, type View, } from "./templating/view.js";

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

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

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

@@ -1,15 +1,15 @@
 import { ExecutionContext } from "../observation/observable.js";
 import type { ViewBehavior, ViewBehaviorTargets } from "../templating/html-directive.js";
 export declare const Fake: Readonly<{
-    executionContext<TParent = any>(parent?: TParent | undefined, parentContext?: ExecutionContext<TParent> | undefined): ExecutionContext<TParent>;
-    viewController<TSource = any, TParent_1 = any>(targets?: ViewBehaviorTargets, ...behaviors: ViewBehavior<TSource, TParent_1>[]): {
+    executionContext<TParent = any>(parent?: TParent, parentContext?: ExecutionContext<TParent>): ExecutionContext<TParent>;
+    viewController<TSource = any, TParent = any>(targets?: ViewBehaviorTargets, ...behaviors: ViewBehavior<TSource, TParent>[]): {
         isBound: boolean;
-        context: ExecutionContext<TParent_1>;
+        context: ExecutionContext<TParent>;
         onUnbind(object: any): void;
         source: TSource;
         targets: ViewBehaviorTargets;
         toJSON: () => undefined;
-        bind(source: TSource, context?: ExecutionContext<TParent_1>): void;
+        bind(source: TSource, context?: ExecutionContext<TParent>): void;
         unbind(): void;
     };
 }>;

package/dist/dts/updates.d.ts

@@ -0,0 +1 @@
+export { type UpdateQueue, Updates } from "./observation/update-queue.js";

package/dist/dts/volatile.d.ts

@@ -0,0 +1,2 @@
+export type { Accessor } from "./observation/observable.js";
+export { volatile } from "./observation/observable.js";

package/dist/esm/__test__/helpers.js

@@ -0,0 +1,22 @@
+export function toHTML(node, preserveCommentMarkup = false) {
+    return Array.from(node.childNodes)
+        .map((x) => {
+        if (preserveCommentMarkup && x.nodeType === 8) {
+            return `<!--${x.textContent}-->`;
+        }
+        return x.outerHTML || x.textContent;
+    })
+        .join("");
+}
+export function createTrackableDOMPolicy() {
+    return {
+        used: false,
+        createHTML: (html) => html,
+        protect(tagName, aspect, aspectName, sink) {
+            return (node, aspectName, value, ...args) => {
+                this.used = true;
+                sink(node, aspectName, value, ...args);
+            };
+        },
+    };
+}

package/dist/esm/__test__/setup-node.js

@@ -0,0 +1,18 @@
+"use strict";
+/* eslint-disable */
+if (window.document && !window.document.createRange) {
+    window.document.createRange = () => ({
+        setStart: () => { },
+        setEnd: () => { },
+        // @ts-ignore
+        commonAncestorContainer: {
+            nodeName: "BODY",
+            ownerDocument: document,
+        },
+    });
+}
+if (!window.requestAnimationFrame) {
+    window.requestAnimationFrame = function (callback) {
+        return setTimeout(callback, 4);
+    };
+}

package/dist/esm/array-observer.js

@@ -0,0 +1 @@
+export { ArrayObserver, Sort, Splice, SpliceStrategy, SpliceStrategySupport, } from "./observation/arrays.js";