@hubspot/ui-extensions 0.11.2 → 0.11.3

package/dist/experimental/testing/__tests__/mocks.actions.spec.js

@@ -0,0 +1,19 @@
+import { describe, it } from 'vitest';
+import { createRenderer } from "../index.js";
+describe('mock actions', () => {
+    it('should provide the ability to spy on the actions for the "crm.record.tab" extension point', () => {
+        const { mocks } = createRenderer('crm.record.tab');
+        const { actions } = mocks;
+        actions.reloadPage();
+        expect(actions.reloadPage.callCount).toBe(1);
+        actions.onCrmPropertiesUpdate(['firstname', 'lastname'], () => { });
+        expect(actions.onCrmPropertiesUpdate.callCount).toBe(1);
+    });
+    it('should provide the ability to spy on the actions for the "settings" extension point', () => {
+        const { mocks } = createRenderer('settings');
+        const { actions } = mocks;
+        actions.addAlert({
+            message: 'Test Alert',
+        });
+    });
+});

package/dist/experimental/testing/__tests__/mocks.context.spec.js

@@ -0,0 +1,24 @@
+import { describe, it } from 'vitest';
+import { createRenderer } from "../index.js";
+describe('mock context', () => {
+    it('should provide reasonable mock data for the "crm.record.tab" extension point', () => {
+        const { mocks } = createRenderer('crm.record.tab');
+        const { context } = mocks;
+        expect(context.location).toBe('crm.record.tab');
+        expect(context.user.email).toBe('fake_email@example.com');
+        expect(context.user.firstName).toBe('fake_firstName');
+        expect(context.user.lastName).toBe('fake_lastName');
+        expect(context.portal.id).toBe(123);
+        expect(context.portal.timezone).toBe('America/New_York');
+        expect(context.crm.objectId).toBe(123);
+        expect(context.crm.objectTypeId).toBe('0-1');
+        expect(context.variables).toEqual({ fake_variable: 'fake_value' });
+    });
+    it('should provide reasonable mock data for the "settings" extension point', () => {
+        const { mocks } = createRenderer('settings');
+        const { context } = mocks;
+        expect(context.location).toBe('settings');
+        expect(context.portal.id).toBe(123);
+        expect(context.portal.timezone).toBe('America/New_York');
+    });
+});

package/dist/experimental/testing/__tests__/mocks.runServerlessFunction.spec.js

@@ -0,0 +1,35 @@
+import { describe, it } from 'vitest';
+import { createRenderer } from "../index.js";
+import { ServerlessExecutionStatus, } from "../../../shared/types/http-requests.js";
+describe('mock runServerlessFunction', () => {
+    it('should provide the ability to spy on the runServerlessFunction function', async () => {
+        const { mocks } = createRenderer('crm.record.tab');
+        const { runServerlessFunction } = mocks;
+        const serverlessExecutionResult = {
+            status: ServerlessExecutionStatus.Success,
+            response: {
+                myFakeData: 'hello',
+                anotherFakeData: 'bye',
+            },
+        };
+        runServerlessFunction.nextResult(Promise.resolve(serverlessExecutionResult));
+        const result = await runServerlessFunction({
+            name: 'fake_function',
+            parameters: {
+                param1: 'value1',
+            },
+            propertiesToSend: ['prop1', 'prop2'],
+        });
+        expect(result).toEqual(serverlessExecutionResult);
+        expect(runServerlessFunction.callCount).toBe(1);
+        expect(runServerlessFunction.calls[0]).toEqual([
+            {
+                name: 'fake_function',
+                parameters: {
+                    param1: 'value1',
+                },
+                propertiesToSend: ['prop1', 'prop2'],
+            },
+        ]);
+    });
+});

package/dist/experimental/testing/__tests__/mocks.useAssociations.spec.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { describe, expect, it } from 'vitest';
+import { Text } from "../../../index.js";
+import { createRenderer } from "../index.js";
+import { useAssociations } from "../../../crm/index.js";
+function MyComponent() {
+    const { results, isLoading, error } = useAssociations({
+        toObjectType: '0-1',
+        properties: ['firstname', 'lastname'],
+        pageLength: 10,
+    });
+    if (isLoading) {
+        return _jsx(Text, { children: "Loading..." });
+    }
+    if (error) {
+        return _jsx(Text, { children: "Something went wrong!" });
+    }
+    return (_jsx(_Fragment, { children: results.map((result) => (_jsxs(Text, { children: [result.properties.firstname, " ", result.properties.lastname] }, result.toObjectId))) }));
+}
+describe('mock useAssociations', () => {
+    it('should provide a default mock implementation', () => {
+        const { render } = createRenderer('crm.record.tab');
+        const { findAll } = render(_jsx(MyComponent, {}));
+        const textNodes = findAll(Text);
+        expect(textNodes.length).toEqual(1);
+        expect(textNodes[0].text).toEqual('fake_firstname fake_lastname');
+    });
+    it('should allow mocking the next function result', () => {
+        const { render, mocks } = createRenderer('crm.record.tab');
+        mocks.useAssociations.nextResult({
+            results: [],
+            error: new Error('Something went wrong!'),
+            isLoading: false,
+            pagination: {
+                hasNextPage: false,
+                hasPreviousPage: false,
+                currentPage: 1,
+                pageSize: 10,
+                nextPage: () => { },
+                previousPage: () => { },
+                reset: () => { },
+            },
+        });
+        const { find } = render(_jsx(MyComponent, {}));
+        expect(find(Text).text).toEqual('Something went wrong!');
+    });
+});

package/dist/experimental/testing/__tests__/mocks.useCrmProperties.spec.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { describe, expect, it } from 'vitest';
+import { Text } from "../../../index.js";
+import { createRenderer } from "../index.js";
+import { useCrmProperties } from "../../../crm/index.js";
+function MyComponent() {
+    const { properties, isLoading, error } = useCrmProperties([
+        'firstname',
+        'lastname',
+    ]);
+    if (isLoading) {
+        return _jsx(Text, { children: "Loading..." });
+    }
+    if (error) {
+        return _jsx(Text, { children: "Something went wrong!" });
+    }
+    return (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["First name: ", properties.firstname] }), _jsxs(Text, { children: ["Last name: ", properties.lastname] })] }));
+}
+describe('mock useCrmProperties', () => {
+    it('should provide a default mock implementation', () => {
+        const { render } = createRenderer('crm.record.tab');
+        const { findAll } = render(_jsx(MyComponent, {}));
+        const textNodes = findAll(Text);
+        expect(textNodes.length).toEqual(2);
+        expect(textNodes[0].text).toEqual('First name: fake_firstname');
+        expect(textNodes[1].text).toEqual('Last name: fake_lastname');
+    });
+    it('should allow mocking the next function result', () => {
+        const { render, mocks } = createRenderer('crm.record.tab');
+        mocks.useCrmProperties.nextResult({
+            properties: {},
+            error: new Error('Something went wrong!'),
+            isLoading: false,
+        });
+        const { find } = render(_jsx(MyComponent, {}));
+        expect(find(Text).text).toEqual('Something went wrong!');
+    });
+    it('should allow providing a custom mock function', () => {
+        const { render, mocks, findAll } = createRenderer('crm.record.tab');
+        mocks.useCrmProperties.willCall((propertyNames) => {
+            const properties = propertyNames.reduce((acc, propertyName) => {
+                acc[propertyName] = propertyName.toUpperCase();
+                return acc;
+            }, {});
+            return {
+                properties,
+                error: null,
+                isLoading: false,
+            };
+        });
+        render(_jsx(MyComponent, {}));
+        const textNodes = findAll(Text);
+        const firstNameText = textNodes[0];
+        const lastNameText = textNodes[1];
+        expect(firstNameText.isMatch(Text) && firstNameText.text).toEqual('First name: FIRSTNAME');
+        expect(lastNameText.isMatch(Text) && lastNameText.text).toEqual('Last name: LASTNAME');
+    });
+});

package/dist/experimental/testing/__tests__/props.spec.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { describe, expect, it } from 'vitest';
+import { Button, ButtonRow } from "../../../index.js";
+import { createRenderer } from "../index.js";
+describe('props', () => {
+    it('should remove the children prop from the props object', () => {
+        const { render, find } = createRenderer('crm.record.tab');
+        render(_jsx(_Fragment, { children: _jsx(ButtonRow, { children: _jsx(Button, { variant: "primary", children: "Click me!" }) }) }));
+        const buttonRow = find(ButtonRow);
+        // @ts-expect-error - children should not be exposed in props
+        expect(buttonRow.props.children).toBeUndefined();
+    });
+});

package/dist/experimental/testing/__tests__/testId.spec.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from "../../../index.js";
+import { createRenderer } from "../index.js";
+import { DuplicateTestIdError } from "../internal/errors.js";
+describe('testId', () => {
+    it('should throw DuplicateTestIdError when testId is already in use', () => {
+        const { render } = createRenderer('crm.record.tab');
+        let error = null;
+        try {
+            render(_jsxs(_Fragment, { children: [_jsx(Button, { variant: "primary", testId: "my-button", children: "Click me" }), _jsx(Button, { variant: "secondary", testId: "my-button", children: "Click me" })] }));
+        }
+        catch (_error) {
+            error = _error;
+        }
+        expect(error).toBeInstanceOf(DuplicateTestIdError);
+        expect(error?.message).toMatchSnapshot();
+    });
+});

package/dist/experimental/testing/__tests__/trigger.spec.js

@@ -1,9 +1,9 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useState } from 'react';
 import { describe, expect, it } from 'vitest';
-import { Button } from '../../../index';
-import { render } from '../index';
-import { InvalidEventFunctionError, MissingEventFunctionError, } from '../internal/errors';
+import { Button } from "../../../index.js";
+import { createRenderer } from "../index.js";
+import { InvalidEventFunctionError, MissingEventFunctionError, } from "../internal/errors.js";
 describe('trigger()', () => {
     it('should allow events to be triggered', () => {
         function Counter() {
@@ -13,7 +13,8 @@ describe('trigger()', () => {
             };
             return (_jsxs(Button, { variant: "primary", onClick: handleClick, children: ["Clicked ", count, " times"] }));
         }
-        const { find } = render(_jsx(Counter, {}));
+        const { render, find } = createRenderer('crm.record.tab');
+        render(_jsx(Counter, {}));
         expect(find(Button).text).toEqual('Clicked 0 times');
         find(Button).trigger('onClick');
         expect(find(Button).text).toEqual('Clicked 1 times');
@@ -22,7 +23,8 @@ describe('trigger()', () => {
         function Counter() {
             return _jsx(Button, { variant: "primary", children: "Click me!" });
         }
-        const { find } = render(_jsx(Counter, {}));
+        const { render, find } = createRenderer('crm.record.tab');
+        render(_jsx(Counter, {}));
         expect(() => {
             find(Button).trigger('onClick');
         }).toThrow(MissingEventFunctionError);
@@ -32,7 +34,8 @@ describe('trigger()', () => {
             const handleClick = {};
             return (_jsx(Button, { variant: "primary", onClick: handleClick, children: "Click me!" }));
         }
-        const { find } = render(_jsx(Counter, {}));
+        const { render, find } = createRenderer('crm.record.tab');
+        render(_jsx(Counter, {}));
         expect(() => {
             find(Button).trigger('onClick');
         }).toThrow(InvalidEventFunctionError);

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

@@ -1,15 +1,16 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { describe, expect, it } from 'vitest';
-import { Button, ButtonRow, Text } from '../../../index';
-import { render } from '../index';
-import { isRenderedElementNode, isRenderedFragmentNode, isRenderedRootNode, isRenderedTextNode, } from '../type-utils';
-import { RenderedNodeType } from '../types';
+import { Button, ButtonRow, Text } from "../../../index.js";
+import { createRenderer } from "../index.js";
+import { isRenderedElementNode, isRenderedFragmentNode, isRenderedRootNode, isRenderedTextNode, } from "../type-utils.js";
+import { RenderedNodeType } from "../types.js";
 const TestComponent = () => (_jsx(Button, { overlay: _jsx(Text, { children: "Hello" }), children: "Text content" }));
 const setupTestNodes = () => {
-    const { find, getRootNode } = render(_jsx(TestComponent, {}));
+    const { render, find, getRootNode } = createRenderer('crm.record.tab');
+    render(_jsx(TestComponent, {}));
     const elementNode = find(Button);
     const rootNode = getRootNode();
-    const textNode = find(Button).children[0];
+    const textNode = find(Button).childNodes[0];
     const fragmentNode = find(Button).props.overlay;
     return {
         elementNode,
@@ -121,9 +122,10 @@ describe('type guard functions', () => {
     });
     describe('type narrowing', () => {
         it('should correctly narrow types for element nodes', () => {
-            const { find } = render(_jsx(ButtonRow, { children: _jsx(Button, { variant: "primary", children: "Click me" }) }));
+            const { render, find } = createRenderer('crm.record.tab');
+            render(_jsx(ButtonRow, { children: _jsx(Button, { variant: "primary", children: "Click me" }) }));
             const buttonRow = find(ButtonRow);
-            const firstChild = buttonRow.children[0];
+            const firstChild = buttonRow.childNodes[0];
             if (isRenderedElementNode(firstChild)) {
                 expect(firstChild.name).toBe('Button');
                 expect(firstChild.props.variant).toBe('primary');
@@ -144,7 +146,7 @@ describe('type guard functions', () => {
         it('should correctly narrow types for root nodes', () => {
             const { rootNode } = setupTestNodes();
             if (isRenderedRootNode(rootNode)) {
-                expect(rootNode.children.length).toBeGreaterThan(0);
+                expect(rootNode.childNodes.length).toBeGreaterThan(0);
             }
             else {
                 throw new Error('Expected root node');
@@ -153,7 +155,7 @@ describe('type guard functions', () => {
         it('should correctly narrow types for fragment nodes', () => {
             const { fragmentNode } = setupTestNodes();
             if (isRenderedFragmentNode(fragmentNode)) {
-                expect(fragmentNode.children.length).toBe(1);
+                expect(fragmentNode.childNodes.length).toBe(1);
             }
             else {
                 throw new Error('Expected fragment node');

package/dist/experimental/testing/__tests__/waitFor.spec.js

@@ -1,9 +1,9 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { Button } from '../../../index';
-import { render } from '../index';
-import { WaitForTimeoutError } from '../internal/errors';
+import { Button } from "../../../index.js";
+import { createRenderer } from "../index.js";
+import { WaitForTimeoutError } from "../internal/errors.js";
 describe('waitFor()', () => {
     beforeEach(() => {
         // tell vitest we use mocked time
@@ -23,7 +23,8 @@ describe('waitFor()', () => {
             }, []);
             return _jsxs(Button, { variant: "primary", children: ["Count: ", count] });
         }
-        const { find, waitFor } = render(_jsx(AsyncCounter, {}));
+        const { render, find, waitFor } = createRenderer('crm.record.tab');
+        render(_jsx(AsyncCounter, {}));
         expect(find(Button).text).toEqual('Count: 0');
         const waitForPromise = waitFor(() => {
             expect(find(Button).text).toEqual('Count: 1');
@@ -42,7 +43,8 @@ describe('waitFor()', () => {
             }, []);
             return _jsxs(Button, { variant: "primary", children: ["Count: ", count] });
         }
-        const { find, waitFor } = render(_jsx(AsyncCounter, {}));
+        const { render, find, waitFor } = createRenderer('crm.record.tab');
+        render(_jsx(AsyncCounter, {}));
         expect(find(Button).text).toEqual('Count: 0');
         const waitForPromise = waitFor(() => {
             expect(find(Button).text).toEqual('Count: 1');

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

@@ -1,3 +1,4 @@
-export * from './type-utils';
-export * from './render';
-export * from './types';
+export * from './type-utils.ts';
+export * from './render.tsx';
+export * from './types.ts';
+export * from './utils.ts';

package/dist/experimental/testing/index.js

@@ -1,3 +1,4 @@
-export * from './type-utils';
-export * from './render';
-export * from './types';
+export * from "./type-utils.js";
+export * from "./render.js";
+export * from "./types.js";
+export * from "./utils.js";

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

@@ -1,2 +1,2 @@
-import { type RenderedChildNode } from '../types';
-export declare const EMPTY_CHILDREN: RenderedChildNode[];
+import { type RenderedChildNode } from '../types.ts';
+export declare const EMPTY_RENDERED_CHILD_NODES: RenderedChildNode[];

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

@@ -1 +1 @@
-export const EMPTY_CHILDREN = [];
+export const EMPTY_RENDERED_CHILD_NODES = [];

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

@@ -1,8 +1,8 @@
 import { type RemoteRoot } from '@remote-ui/core';
-import type { RenderedRootNodeInternal } from './types-internal';
+import type { RenderedRootNodeInternal } from './types-internal.ts';
 /**
  * Converts a remote root node to a rendered root node. After conversion, the rendered root node will
- * have its children set to the converted children.
+ * have its `childNodes` property set to the converted child nodes.
  *
  * @param rootNode The rendered root node to convert.
  * @param remoteRoot The remote root node to convert.

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

@@ -1,11 +1,12 @@
 import { KIND_COMPONENT, KIND_FRAGMENT, KIND_TEXT, } from '@remote-ui/core';
-import { createElementNode } from './element';
-import { InvalidFragmentPropArrayError } from './errors';
-import { createFragmentNode } from './fragment';
-import { createTextNode } from './text';
-import { isRenderedTextNode } from '../type-utils';
-import { __hubSpotComponentRegistry } from '../../../__synced__/remoteComponents.synced';
-import { EMPTY_CHILDREN } from './constants';
+import { createElementNode } from "./element.js";
+import { DuplicateTestIdError, InvalidFragmentPropArrayError, } from "./errors.js";
+import { createFragmentNode } from "./fragment.js";
+import { createTextNode } from "./text.js";
+import { __hubSpotComponentRegistry } from "../../../shared/remoteComponents.js";
+import { isRenderedTextNode } from "../type-utils.js";
+import { EMPTY_RENDERED_CHILD_NODES } from "./constants.js";
+import { asRenderedParentNode } from "./type-utils-internal.js";
 /* eslint-disable @typescript-eslint/no-use-before-define */
 /**
  * Converts a remote props object to a props object that can be attached to a rendered element node.
@@ -31,15 +32,15 @@ const convertRemoteProps = (document, componentName, remoteProps) => {
             }
             const fragmentNode = createFragmentNode(document);
             if (remotePropValue == null) {
-                fragmentNode.children = EMPTY_CHILDREN;
+                fragmentNode.childNodes = EMPTY_RENDERED_CHILD_NODES;
             }
             else if (typeof remotePropValue === 'string') {
                 const text = remotePropValue;
                 fragmentNode.text = text;
-                fragmentNode.children = [createTextNode(text)];
+                fragmentNode.childNodes = [createTextNode(document, text)];
             }
             else if (remotePropValue.kind === KIND_FRAGMENT) {
-                convertRemoteChildren(fragmentNode, remotePropValue);
+                convertRemoteChildren(document, fragmentNode, remotePropValue);
             }
             convertedProps[propName] = fragmentNode;
         }
@@ -59,7 +60,7 @@ const convertRemoteProps = (document, componentName, remoteProps) => {
  */
 const convertChildNode = (document, remoteChild) => {
     if (remoteChild.kind === KIND_TEXT) {
-        return createTextNode(remoteChild);
+        return createTextNode(document, remoteChild);
     }
     else if (remoteChild.kind === KIND_COMPONENT) {
         const name = remoteChild.type;
@@ -68,7 +69,23 @@ const convertChildNode = (document, remoteChild) => {
         if (!__hubSpotComponentRegistry.isAllowedComponentName(name)) {
             document.addInvalidComponentName(name);
         }
-        convertRemoteChildren(elementNode, remoteChild);
+        const { testId } = props;
+        if (testId) {
+            // If the element has a test ID we will put the element in a lookup map for
+            // efficient queries using `findByTestId()`/`maybeFindByTestId()`.
+            // First, we need to check if it is already in use and throw an error if it is.
+            const existingElement = document.testIdToElementMap.get(testId);
+            if (existingElement) {
+                throw new DuplicateTestIdError({
+                    testId,
+                    previousElement: existingElement,
+                    newElement: elementNode,
+                });
+            }
+            // If the test ID is not already in use, we can add the element to the lookup map.
+            document.testIdToElementMap.set(testId, elementNode);
+        }
+        convertRemoteChildren(document, elementNode, remoteChild);
         return elementNode;
     }
     else {
@@ -76,14 +93,14 @@ const convertChildNode = (document, remoteChild) => {
     }
 };
 /**
- * Converts the children a remote parent node to a rendered parent node. After conversion, the rendered parent node will
- * have its children set to the converted children.
+ * Converts the children of a remote parent node to our rendered child nodes.
+ * After conversion, the rendered parent node will have its `childNodes` property set
+ * to the converted child nodes.
  *
  * @param parentNode The rendered parent node to convert.
  * @param remoteParentNode The remote parent node to convert.
  */
-const convertRemoteChildren = (parentNode, remoteParentNode) => {
-    const { document } = parentNode;
+const convertRemoteChildren = (document, parentNode, remoteParentNode) => {
     const remoteChildren = remoteParentNode.children;
     if (remoteChildren == null) {
         return;
@@ -91,11 +108,11 @@ const convertRemoteChildren = (parentNode, remoteParentNode) => {
     if (typeof remoteChildren === 'string') {
         const text = remoteChildren;
         parentNode.text = text;
-        parentNode.children = [createTextNode(text)];
+        parentNode.childNodes = [createTextNode(document, text)];
         return;
     }
     let text = null;
-    const children = [];
+    const convertedChildNodes = [];
     let lastRenderedChild;
     for (const remoteChild of remoteChildren) {
         if (remoteChild.kind === KIND_TEXT) {
@@ -112,20 +129,21 @@ const convertRemoteChildren = (parentNode, remoteParentNode) => {
                 continue;
             }
         }
-        const renderedChild = convertChildNode(document, remoteChild);
-        children.push(renderedChild);
-        lastRenderedChild = renderedChild;
+        const renderedChildNode = convertChildNode(document, remoteChild);
+        convertedChildNodes.push(renderedChildNode);
+        lastRenderedChild = renderedChildNode;
     }
     parentNode.text = text;
-    parentNode.children = children;
+    parentNode.childNodes = convertedChildNodes;
 };
 /**
  * Converts a remote root node to a rendered root node. After conversion, the rendered root node will
- * have its children set to the converted children.
+ * have its `childNodes` property set to the converted child nodes.
  *
  * @param rootNode The rendered root node to convert.
  * @param remoteRoot The remote root node to convert.
  */
 export const convertRemoteRoot = (rootNode, remoteRoot) => {
-    convertRemoteChildren(rootNode, remoteRoot);
+    const { document } = rootNode;
+    convertRemoteChildren(document, asRenderedParentNode(rootNode), remoteRoot);
 };

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

@@ -1,8 +1,8 @@
-import type { RenderedParentNode } from '../types';
+import { RenderedNode } from '../types.ts';
 /**
  * Logs a rendered node tree to the console for debugging purposes.
  *
- * @param parentNode The node to log.
+ * @param node The node to log.
  * @param label Optional label to display before the node tree.
  */
-export declare const debugLog: (parentNode: RenderedParentNode, label?: string) => void;
+export declare const debugLog: (node: RenderedNode, label?: string) => void;

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

@@ -1,13 +1,12 @@
-import { printNode } from './print';
-/* eslint-disable @typescript-eslint/no-unused-vars */
+import { printNode } from "./print.js";
 /**
  * Logs a rendered node tree to the console for debugging purposes.
  *
- * @param parentNode The node to log.
+ * @param node The node to log.
  * @param label Optional label to display before the node tree.
  */
-export const debugLog = (parentNode, label) => {
-    const componentTreeString = printNode(parentNode);
+export const debugLog = (node, label) => {
+    const componentTreeString = printNode(node);
     const separator = ''.padEnd(label?.length ?? 20, '=');
     const logLines = [separator];
     if (label) {

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

@@ -1,4 +1,4 @@
-import type { RenderedDocumentInternal, RenderedRootNodeInternal } from './types-internal';
+import type { RenderedDocumentInternal, RenderedRootNodeInternal } from './types-internal.ts';
 export interface CreateDocumentOptions {
     /**
      * A function that can be called to get the latest rendered root node.

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

@@ -1,5 +1,5 @@
 import { act as reactAct } from 'react';
-import { InvalidComponentsError } from './errors';
+import { InvalidComponentsError } from "./errors.js";
 /**
  * Creates a rendered document.
  *
@@ -9,8 +9,11 @@ import { InvalidComponentsError } from './errors';
 export const createDocument = (options) => {
     const { getLatestRootNode } = options;
     const invalidComponentNames = new Set();
+    // A lookup map of test IDs to elements.
+    const testIdToElementMap = new Map();
     const document = {
         rootNode: null,
+        testIdToElementMap,
         batchUpdate: (run) => {
             reactAct(run);
             const latestRootNode = getLatestRootNode();

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

@@ -1,5 +1,6 @@
-import type { UnknownComponentProps } from '../../../__synced__/types/shared.synced';
-import type { RenderedDocumentInternal, RenderedElementNodeInternal } from './types-internal';
+import type { UnknownComponentProps } from '../../../shared/types/shared.ts';
+import { RenderedElementNode } from '../types.ts';
+import type { RenderedDocumentInternal } from './types-internal.ts';
 /**
  * Creates a rendered element node.
  *
@@ -8,4 +9,4 @@ import type { RenderedDocumentInternal, RenderedElementNodeInternal } from './ty
  * @param props The props of the element.
  * @returns A rendered element node.
  */
-export declare const createElementNode: (document: RenderedDocumentInternal, name: string, props: UnknownComponentProps) => RenderedElementNodeInternal;
+export declare const createElementNode: (document: RenderedDocumentInternal, name: string, props: UnknownComponentProps) => RenderedElementNode;