@hubspot/ui-extensions 0.10.1 → 0.11.1

package/dist/experimental/testing/internal/query.js

@@ -0,0 +1,231 @@
+import { __hubSpotComponentRegistry } from '../../../__synced__/remoteComponents.synced';
+import { isRenderedElementNode, isRenderedFragmentNode } from '../type-utils';
+import { ComponentNotFoundError, FindInvalidComponentError, InvalidComponentsError, } from './errors';
+/**
+ * Checks if the element matches the matcher.
+ *
+ * @param element The element to check.
+ * @param matcher An optional matcher to filter the elements.
+ * @returns `true` if the element matches the matcher, `false` otherwise.
+ */
+const checkElementMatches = (element, matcher) => {
+    // If no matcher is provided, the element matches
+    if (!matcher) {
+        return true;
+    }
+    // Check if the matcher is a predicate function
+    if (typeof matcher === 'function') {
+        return matcher(element);
+    }
+    // Check if all the props in the matcher match the props in the element
+    return Object.keys(matcher).every((key) => element.props[key] === matcher[key]);
+};
+const addMatchToFindResult = (findResult, match, options) => {
+    if (options.findFirstOnly) {
+        findResult.match = match;
+    }
+    else {
+        findResult.allMatches.push(match);
+    }
+};
+/**
+ * Recursive helper for finding elements in the rendered tree.
+ * NOTE: The input `findResult` is mutated in place.
+ *
+ * @param parentNode The parent node to search in.
+ * @param options The options for the find operation.
+ * @param findResult The find result to mutate.
+ */
+const findInternalHelper = (parentNode, options, findResult) => {
+    const { children } = parentNode;
+    const { targetComponent, matcher, findFirstOnly, findDirectChildrenOnly } = options;
+    const targetComponentName = __hubSpotComponentRegistry.getComponentName(targetComponent);
+    for (const child of children) {
+        if (!isRenderedElementNode(child)) {
+            // Skip over non-element child nodes (just text nodes)
+            continue;
+        }
+        if (child.name === targetComponentName &&
+            checkElementMatches(child, matcher)) {
+            // We found a match, so add it to the find result
+            addMatchToFindResult(findResult, child, options);
+            if (findFirstOnly) {
+                return;
+            }
+        }
+        // We only search in nested children and fragment props if we're not only looking for children
+        if (!findDirectChildrenOnly) {
+            // Search for the component in the fragment props
+            const { props } = child;
+            const fragmentProps = __hubSpotComponentRegistry.getComponentFragmentPropNames(child.name);
+            for (const fragmentPropName of fragmentProps) {
+                const maybeFragment = props[fragmentPropName];
+                // NOTE: As part of the conversion process of converting remote nodes to rendered nodes, we
+                //       create a RenderedFragmentNode for each fragment prop and put that into the props object.
+                if (isRenderedFragmentNode(maybeFragment)) {
+                    findInternalHelper(maybeFragment, options, findResult);
+                    if (findFirstOnly && findResult.match) {
+                        return;
+                    }
+                }
+            }
+            // Search for the component in the child
+            findInternalHelper(child, options, findResult);
+            if (findFirstOnly && findResult.match) {
+                return;
+            }
+        }
+    }
+    return;
+};
+/**
+ * Internal utility that centralizes finding elements in the rendered tree (including error handling).
+ *
+ * @param parentNode The parent node to search in.
+ * @param options The options for the find operation.
+ * @returns The find result.
+ */
+const findInternal = (parentNode, options) => {
+    const { document } = parentNode;
+    const { targetComponent, findMethodName, shouldThrowErrorIfNotFound } = options;
+    const targetComponentName = __hubSpotComponentRegistry.getComponentName(targetComponent);
+    if (!targetComponentName) {
+        throw new FindInvalidComponentError({
+            findMethodName,
+        });
+    }
+    // We always validate the document before running the find operation since the document may
+    // have been updated asynchronously in the background.
+    if (document.hasInvalidComponentNames()) {
+        throw new InvalidComponentsError(document.rootNode);
+    }
+    // Initialize the find result that will be mutated in place
+    const findResult = {
+        match: null,
+        allMatches: [],
+    };
+    // Run the internal find helper to recursively search the rendered tree
+    findInternalHelper(parentNode, options, findResult);
+    if (findResult.match === null && shouldThrowErrorIfNotFound) {
+        throw new ComponentNotFoundError({
+            findMethodName: options.findMethodName,
+            parentNode,
+            componentName: targetComponentName,
+        });
+    }
+    return findResult;
+};
+/**
+ * Finds the first descendant element node that matches the given component.
+ *
+ * @param parentNode The parent node to search in.
+ * @param targetComponent The component to find.
+ * @param matcher An optional matcher to filter the elements.
+ * @returns The first element node that matches the given component or `null` if no match is found.
+ */
+export const maybeFind = (parentNode, targetComponent, matcher) => {
+    const { match } = findInternal(parentNode, {
+        targetComponent,
+        matcher,
+        findFirstOnly: true,
+        findDirectChildrenOnly: false,
+        findMethodName: 'maybeFind',
+        shouldThrowErrorIfNotFound: false,
+    });
+    return match;
+};
+/**
+ * Finds the first descendant element node that matches the given component.
+ *
+ * @param parentNode The parent node to search in.
+ * @param targetComponent The component to find.
+ * @param matcher An optional matcher to filter the elements.
+ * @returns The first element node that matches the given component.
+ */
+export const find = (parentNode, targetComponent, matcher) => {
+    const { match } = findInternal(parentNode, {
+        targetComponent,
+        matcher,
+        findFirstOnly: true,
+        findDirectChildrenOnly: false,
+        findMethodName: 'find',
+        shouldThrowErrorIfNotFound: true,
+    });
+    return match;
+};
+/**
+ * Finds all descendant element nodes that match the given component.
+ *
+ * @param parentNode The parent node to search in.
+ * @param targetComponent The component to find.
+ * @param matcher An optional matcher to filter the elements.
+ * @returns An array of element nodes that match the given component.
+ */
+export const findAll = (parentNode, targetComponent, matcher) => {
+    const { allMatches } = findInternal(parentNode, {
+        targetComponent,
+        matcher,
+        findFirstOnly: false,
+        findDirectChildrenOnly: false,
+        findMethodName: 'findAll',
+        shouldThrowErrorIfNotFound: false,
+    });
+    return allMatches;
+};
+/**
+ * Finds the first direct child element node that matches the given component.
+ *
+ * @param parentNode The parent node to search in.
+ * @param targetComponent The component to find.
+ * @param matcher An optional matcher to filter the elements.
+ * @returns The first child element node that matches the given component.
+ */
+export const findChild = (parentNode, targetComponent, matcher) => {
+    const { match } = findInternal(parentNode, {
+        targetComponent,
+        matcher,
+        findFirstOnly: true,
+        findDirectChildrenOnly: true,
+        findMethodName: 'findChild',
+        shouldThrowErrorIfNotFound: true,
+    });
+    return match;
+};
+/**
+ * Finds the first direct child element node that matches the given component.
+ *
+ * @param parentNode The parent node to search in.
+ * @param targetComponent The component to find.
+ * @param matcher An optional matcher to filter the elements.
+ * @returns The first child element node that matches the given component.
+ */
+export const maybeFindChild = (parentNode, targetComponent, matcher) => {
+    const { match } = findInternal(parentNode, {
+        targetComponent,
+        matcher,
+        findFirstOnly: true,
+        findDirectChildrenOnly: true,
+        findMethodName: 'maybeFindChild',
+        shouldThrowErrorIfNotFound: false,
+    });
+    return match;
+};
+/**
+ * Finds all direct child element nodes that match the given component.
+ *
+ * @param parentNode The parent node to search in.
+ * @param targetComponent The component to find.
+ * @param matcher An optional matcher to filter the elements.
+ * @returns An array of child element nodes that match the given component.
+ */
+export const findAllChildren = (parentNode, targetComponent, matcher) => {
+    const { allMatches } = findInternal(parentNode, {
+        targetComponent,
+        matcher,
+        findFirstOnly: false,
+        findDirectChildrenOnly: true,
+        findMethodName: 'findAllChildren',
+        shouldThrowErrorIfNotFound: false,
+    });
+    return allMatches;
+};

package/dist/experimental/testing/internal/root.d.ts

@@ -0,0 +1,8 @@
+import type { RenderedDocumentInternal, RenderedRootNodeInternal } from './types-internal';
+/**
+ * Creates a rendered root node.
+ *
+ * @param document The document that the root belongs to.
+ * @returns A rendered root node.
+ */
+export declare const createRootNode: (document: RenderedDocumentInternal) => RenderedRootNodeInternal;

package/dist/experimental/testing/internal/root.js

@@ -0,0 +1,44 @@
+import { RenderedNodeType } from '../types';
+import { EMPTY_CHILDREN } from './constants';
+import { debugLog } from './debug';
+import { printNode } from './print';
+import { find, findAll, findAllChildren, findChild, maybeFind, maybeFindChild, } from './query';
+/**
+ * Creates a rendered root node.
+ *
+ * @param document The document that the root belongs to.
+ * @returns A rendered root node.
+ */
+export const createRootNode = (document) => {
+    const rootNode = {
+        nodeType: RenderedNodeType.Root,
+        text: null,
+        children: EMPTY_CHILDREN,
+        document,
+        debugLog: (label) => {
+            debugLog(rootNode, label);
+        },
+        find: (targetComponent, matcher) => {
+            return find(rootNode, targetComponent, matcher);
+        },
+        findAll: (targetComponent, matcher) => {
+            return findAll(rootNode, targetComponent, matcher);
+        },
+        findChild: (targetComponent, matcher) => {
+            return findChild(rootNode, targetComponent, matcher);
+        },
+        findAllChildren: (targetComponent, matcher) => {
+            return findAllChildren(rootNode, targetComponent, matcher);
+        },
+        maybeFind: (targetComponent, matcher) => {
+            return maybeFind(rootNode, targetComponent, matcher);
+        },
+        maybeFindChild: (targetComponent, matcher) => {
+            return maybeFindChild(rootNode, targetComponent, matcher);
+        },
+        toString: () => {
+            return printNode(rootNode);
+        },
+    };
+    return rootNode;
+};

package/dist/experimental/testing/internal/text.d.ts

@@ -0,0 +1,9 @@
+import { type RemoteRoot, type RemoteText } from '@remote-ui/core';
+import { type RenderedTextNode } from '../types';
+/**
+ * Creates a rendered text node.
+ *
+ * @param remoteText The remote text node or string to create a text node from.
+ * @returns A rendered text node.
+ */
+export declare const createTextNode: (remoteText: RemoteText<RemoteRoot> | string) => RenderedTextNode;

package/dist/experimental/testing/internal/text.js

@@ -0,0 +1,16 @@
+import { RenderedNodeType } from '../types';
+/**
+ * Creates a rendered text node.
+ *
+ * @param remoteText The remote text node or string to create a text node from.
+ * @returns A rendered text node.
+ */
+export const createTextNode = (remoteText) => {
+    const text = typeof remoteText === 'string' ? remoteText : remoteText.text;
+    const textNode = {
+        nodeType: RenderedNodeType.Text,
+        text,
+        toString: () => text,
+    };
+    return textNode;
+};

package/dist/experimental/testing/internal/types-internal.d.ts

@@ -0,0 +1,47 @@
+import type { RemoteComponent, RemoteFragment, RemoteRoot, RemoteText } from '@remote-ui/core';
+import type { RenderedElementNode, RenderedFragmentNode, RenderedNode, RenderedParentNode, RenderedRootNode, RenderedTextNode } from '../types';
+export type RemoteChildNode = RemoteComponent<any, RemoteRoot> | RemoteText<RemoteRoot>;
+export type RemoteParentNode = RemoteRoot | RemoteComponent<any, RemoteRoot> | RemoteFragment;
+/**
+ * Represents a rendered document.
+ */
+export interface RenderedDocumentInternal {
+    /**
+     * The root node of the document.
+     */
+    rootNode: RenderedRootNodeInternal | null;
+    /**
+     * Adds the name of an invalid component to the document.
+     *
+     * @param name The name of the invalid component.
+     */
+    addInvalidComponentName: (name: string) => void;
+    /**
+     * @returns the names of the invalid components.
+     */
+    getInvalidComponentNames: () => string[];
+    /**
+     * @returns Returns `true` if the document has invalid component types. `false` otherwise.
+     */
+    hasInvalidComponentNames: () => boolean;
+    /**
+     * Used to wrap the execution of a function that updates the rendered DOM.
+     * This is used to validate the rendered DOM after the function has been executed.
+     *
+     * @param run The function to execute.
+     */
+    batchUpdate: (run: () => void) => void;
+}
+/**
+ * Adds the `document` property to the rendered node. We do not include this in the public types because it is not
+ * part of the public API, but we need it for internal use.
+ */
+type MakeRenderedNodeInternal<TRenderedNode extends RenderedNode> = TRenderedNode & {
+    document: RenderedDocumentInternal;
+};
+export type RenderedElementNodeInternal = MakeRenderedNodeInternal<RenderedElementNode>;
+export type RenderedTextNodeInternal = MakeRenderedNodeInternal<RenderedTextNode>;
+export type RenderedRootNodeInternal = MakeRenderedNodeInternal<RenderedRootNode>;
+export type RenderedFragmentNodeInternal = MakeRenderedNodeInternal<RenderedFragmentNode>;
+export type RenderedParentNodeInternal = MakeRenderedNodeInternal<RenderedParentNode>;
+export {};

package/dist/experimental/testing/internal/types-internal.js

@@ -0,0 +1 @@
+export {};

package/dist/experimental/testing/type-utils.d.ts

@@ -0,0 +1,29 @@
+import { type RenderedElementNode, type RenderedFragmentNode, type RenderedNode, type RenderedRootNode, type RenderedTextNode } from './types';
+/**
+ * Type guard to check if a node is a rendered element node.
+ *
+ * @param node The node to check.
+ * @returns `true` if the node is a rendered element node.
+ */
+export declare const isRenderedElementNode: (node: RenderedNode | null | undefined) => node is RenderedElementNode<import("../..").UnknownComponentProps>;
+/**
+ * Type guard to check if a node is a rendered text node.
+ *
+ * @param node The node to check.
+ * @returns `true` if the node is a rendered text node.
+ */
+export declare const isRenderedTextNode: (node: RenderedNode | null | undefined) => node is RenderedTextNode;
+/**
+ * Type guard to check if a node is a rendered root node.
+ *
+ * @param node The node to check.
+ * @returns `true` if the node is a rendered root node.
+ */
+export declare const isRenderedRootNode: (node: RenderedNode | null | undefined) => node is RenderedRootNode;
+/**
+ * Type guard to check if a node is a rendered fragment node.
+ *
+ * @param node The node to check.
+ * @returns `true` if the node is a rendered fragment node.
+ */
+export declare const isRenderedFragmentNode: (node: RenderedNode | null | undefined) => node is RenderedFragmentNode;

package/dist/experimental/testing/type-utils.js

@@ -0,0 +1,37 @@
+import { RenderedNodeType, } from './types';
+/**
+ * Type guard to check if a node is a rendered element node.
+ *
+ * @param node The node to check.
+ * @returns `true` if the node is a rendered element node.
+ */
+export const isRenderedElementNode = (node) => {
+    return node?.nodeType === RenderedNodeType.Element;
+};
+/**
+ * Type guard to check if a node is a rendered text node.
+ *
+ * @param node The node to check.
+ * @returns `true` if the node is a rendered text node.
+ */
+export const isRenderedTextNode = (node) => {
+    return node?.nodeType === RenderedNodeType.Text;
+};
+/**
+ * Type guard to check if a node is a rendered root node.
+ *
+ * @param node The node to check.
+ * @returns `true` if the node is a rendered root node.
+ */
+export const isRenderedRootNode = (node) => {
+    return node?.nodeType === RenderedNodeType.Root;
+};
+/**
+ * Type guard to check if a node is a rendered fragment node.
+ *
+ * @param node The node to check.
+ * @returns `true` if the node is a rendered fragment node.
+ */
+export const isRenderedFragmentNode = (node) => {
+    return node?.nodeType === RenderedNodeType.Fragment;
+};

package/dist/experimental/testing/types.d.ts

@@ -0,0 +1,240 @@
+import { HubSpotReactComponent, HubSpotReactFragmentProp, UnknownComponentProps } from '../../__synced__/types/shared.synced';
+/**
+ * The type of a rendered node.
+ */
+export declare enum RenderedNodeType {
+    Root = "root",
+    Fragment = "fragment",
+    Element = "element",
+    Text = "text"
+}
+/**
+ * Extracts event property names from a props type, filtering for properties that are functions
+ */
+type EventNamesForProps<TProps extends UnknownComponentProps> = {
+    [K in keyof Required<TProps>]: Required<TProps>[K] extends Function ? K : never;
+}[keyof TProps];
+interface CommonQueryMethods {
+    /**
+     * Finds the first descendant element node that matches the given component.
+     *
+     * @param component The component to find.
+     * @param matcher An optional matcher to filter the elements.
+     * @returns The first element node that matches the given component or `null` if no match is found.
+     */
+    maybeFind<TProps extends UnknownComponentProps>(component: HubSpotReactComponent<TProps>, matcher?: ElementMatcher<TProps>): RenderedElementNode<TProps> | null;
+    /**
+     * Finds the first descendant element node that matches the given component. If no match is found, an error will be thrown.
+     *
+     * @param component The component to find.
+     * @param matcher An optional matcher to filter the elements.
+     * @returns The first element node that matches the given component.
+     */
+    find<TProps extends UnknownComponentProps>(component: HubSpotReactComponent<TProps>, matcher?: ElementMatcher<TProps>): RenderedElementNode<TProps>;
+    /**
+     * Finds all descendant element nodes that match the given component.
+     *
+     * @param component The component to find.
+     * @param matcher An optional matcher to filter the elements.
+     * @returns An array of element nodes that match the given component.
+     */
+    findAll<TProps extends UnknownComponentProps>(component: HubSpotReactComponent<TProps>, matcher?: ElementMatcher<TProps>): RenderedElementNode<TProps>[];
+    /**
+     * Finds the first direct child element node that matches the given component.
+     *
+     * @param component The component to find.
+     * @param matcher An optional matcher to filter the elements.
+     * @returns The first child element node that matches the given component.
+     */
+    findChild<TProps extends UnknownComponentProps>(component: HubSpotReactComponent<TProps>, matcher?: ElementMatcher<TProps>): RenderedElementNode<TProps>;
+    /**
+     * Finds the first direct child element node that matches the given component.
+     *
+     * @param component The component to find.
+     * @param matcher An optional matcher to filter the elements.
+     * @returns The first child element node that matches the given component or `null` if no match is found.
+     */
+    maybeFindChild<TProps extends UnknownComponentProps>(component: HubSpotReactComponent<TProps>, matcher?: ElementMatcher<TProps>): RenderedElementNode<TProps> | null;
+    /**
+     * Finds all direct child element nodes that match the given component.
+     *
+     * @param component The component to find.
+     * @param matcher An optional matcher to filter the elements.
+     * @returns An array of child element nodes that match the given component.
+     */
+    findAllChildren<TProps extends UnknownComponentProps>(component: HubSpotReactComponent<TProps>, matcher?: ElementMatcher<TProps>): RenderedElementNode<TProps>[];
+}
+interface BaseRenderedParentNode {
+    /**
+     * The child nodes
+     */
+    children: RenderedChildNode[];
+}
+/**
+ * Represents a root node of a rendered component.
+ *
+ * NOTE: Rendered root nodes are immutable and are part of a snapshot for a single render cycle. They become immediately stale when a new render occurs.
+ */
+export interface RenderedRootNode extends BaseRenderedParentNode, CommonQueryMethods {
+    /**
+     * The type of the node (always `RenderedNodeType.Root` for a root node).
+     */
+    nodeType: RenderedNodeType.Root;
+    /**
+     * The text content of the root node or `null` if the root node does not have any text content.
+     */
+    text: string | null;
+    /**
+     * Logs a string representation of the root node as a console log.
+     */
+    debugLog: (label?: string) => void;
+    /**
+     * Returns a string representation of the root node.
+     *
+     * @returns A string representation of the root node.
+     */
+    toString: () => string;
+}
+/**
+ * Represents a fragment node passed as a prop to a rendered component.
+ *
+ * NOTE: Rendered fragment nodes are immutable and are part of a snapshot for a single render cycle. They become immediately stale when a new render occurs.
+ */
+export interface RenderedFragmentNode extends BaseRenderedParentNode, CommonQueryMethods {
+    /**
+     * The type of the node (always `RenderedNodeType.Fragment` for a fragment node).
+     */
+    nodeType: RenderedNodeType.Fragment;
+    /**
+     * The text content of the fragment node or `null` if the fragment node does not have any text content.
+     */
+    text: string | null;
+    /**
+     * Logs a string representation of the fragment node as a console log.
+     */
+    debugLog: (label?: string) => void;
+    /**
+     * Returns a string representation of the fragment node.
+     */
+    toString: () => string;
+}
+type RenderPropsFromComponentProps<TProps extends UnknownComponentProps> = {
+    [K in keyof TProps]: HubSpotReactFragmentProp extends TProps[K] ? RenderedFragmentNode : TProps[K];
+};
+/**
+ * Represents an element node of a rendered component.
+ *
+ * NOTE: Rendered elements are immutable and are part of a snapshot for a single render cycle. They become immediately stale when a new render occurs.
+ */
+export interface RenderedElementNode<TProps extends UnknownComponentProps = UnknownComponentProps> extends BaseRenderedParentNode, CommonQueryMethods {
+    /**
+     * The type of the node (always `RenderedNodeType.Element` for an element node).
+     */
+    nodeType: RenderedNodeType.Element;
+    /**
+     * The name of the element node.
+     */
+    name: string;
+    /**
+     * The props passed to the element node.
+     */
+    props: RenderPropsFromComponentProps<TProps>;
+    /**
+     * The text content of the element node or `null` if the element node does not have any text content.
+     */
+    text: string | null;
+    /**
+     * Logs a string representation of the element node as a console log.
+     *
+     * @param label The label to log.
+     */
+    debugLog: (label?: string) => void;
+    /**
+     * Returns a string representation of the element node.
+     */
+    toString: () => string;
+    /**
+     * Triggers an event function on the element node.
+     *
+     * @param eventPropName The name of the event to trigger.
+     * @param eventArg The argument to pass to the event.
+     */
+    trigger<TEventPropName extends EventNamesForProps<TProps>>(eventPropName: TEventPropName, eventArg?: TProps[TEventPropName]): void;
+}
+/**
+ * Represents a text node of a rendered component.
+ *
+ * NOTE: Rendered text nodes are immutable and are part of a snapshot for a single render cycle. They become immediately stale when a new render occurs.
+ */
+export interface RenderedTextNode {
+    /**
+     * The type of the node (always `RenderedNodeType.Text` for a text node).
+     */
+    nodeType: RenderedNodeType.Text;
+    /**
+     * The text content of the text node.
+     */
+    text: string;
+    /**
+     * Returns a string representation of the text node.
+     */
+    toString: () => string;
+}
+/**
+ * Represents a child node of a parent node.
+ *
+ * NOTE: Rendered child nodes are immutable and are part of a snapshot for a single render cycle. They become immediately stale when a new render occurs.
+ */
+export type RenderedChildNode = RenderedElementNode<UnknownComponentProps> | RenderedTextNode;
+/**
+ * Represents a parent node of a rendered component.
+ *
+ * NOTE: Rendered parent nodes are immutable and are part of a snapshot for a single render cycle. They become immediately stale when a new render occurs.
+ */
+export type RenderedParentNode = RenderedElementNode<UnknownComponentProps> | RenderedRootNode | RenderedFragmentNode;
+/**
+ * A predicate that matches an element node.
+ *
+ * @param node The node to match.
+ * @returns Whether the node matches the predicate.
+ */
+export type ElementMatcherPredicate<TProps extends UnknownComponentProps> = (node: RenderedElementNode<TProps>) => boolean;
+/**
+ * A matcher that matches an element node based on either a predicate or a partial set of properties.
+ */
+export type ElementMatcher<TProps extends UnknownComponentProps> = ElementMatcherPredicate<TProps> | Partial<TProps>;
+/**
+ * Options for the waitFor function.
+ */
+export interface WaitForOptions {
+    /**
+     * The timeout in milliseconds. Defaults to 1000.
+     */
+    timeoutInMs?: number;
+}
+/**
+ * A result of a render operation.
+ */
+export interface RenderResult extends CommonQueryMethods {
+    /**
+     * Waits for the given check to pass. If the check does not pass within the allowed amount of time, an error will be thrown.
+     *
+     * @param check The check to wait for.
+     * @returns A promise that resolves when the check passes.
+     */
+    waitFor: (check: () => void, options?: WaitForOptions) => Promise<void>;
+    /**
+     * Logs a string representation of the rendered output as a console log.
+     *
+     * @param label The label to log.
+     */
+    debugLog: (label?: string) => void;
+    /**
+     * Returns the root node.
+     *
+     * @returns The root node.
+     */
+    getRootNode: () => RenderedRootNode;
+}
+export type RenderedNode = RenderedElementNode<any> | RenderedRootNode | RenderedFragmentNode | RenderedTextNode;
+export {};

package/dist/experimental/testing/types.js

@@ -0,0 +1,10 @@
+/**
+ * The type of a rendered node.
+ */
+export var RenderedNodeType;
+(function (RenderedNodeType) {
+    RenderedNodeType["Root"] = "root";
+    RenderedNodeType["Fragment"] = "fragment";
+    RenderedNodeType["Element"] = "element";
+    RenderedNodeType["Text"] = "text";
+})(RenderedNodeType || (RenderedNodeType = {}));