/*!
* Copyright (c) Microsoft Corporation and contributors. All rights reserved.
* Licensed under the MIT License.
*/
import { strict as assert } from "node:assert";
import { SchemaFactory } from "@fluidframework/tree";
import { render } from "@testing-library/react";
import globalJsdom from "global-jsdom";
import { toPropTreeNode, type PropTreeNode } from "../propNode.js";
import { objectIdNumber } from "../simpleIdentifier.js";
import {
usePropTreeNode,
withMemoizedTreeObservations,
withTreeObservations,
} from "../useTree.js";
describe("useTree", () => {
describe("dom tests", () => {
let cleanup: () => void;
before(() => {
cleanup = globalJsdom();
});
after(() => {
cleanup();
});
it("withTreeObservations example", () => {
const builder = new SchemaFactory("example");
class Item extends builder.object("Item", { text: SchemaFactory.string }) {}
const ItemComponentBug = ({ item }: { item: Item }): JSX.Element => (
{item.text} // Reading `text`, a mutable value from a React prop, causes an invalidation bug.
);
const ItemComponent = withTreeObservations(
({ item }: { item: Item }): JSX.Element => {item.text},
);
const ItemParentComponent = ({ item }: { item: PropTreeNode- }): JSX.Element => (
);
const InvalidItemParentComponent = ({
item,
}: {
item: PropTreeNode
- ;
}): JSX.Element => (
// @ts-expect-error PropTreeNode turns this invalidation bug into a compile error
{item.text}
);
});
for (const reactStrictMode of [false, true]) {
/**
* Check then clear, the contents of `log`.
*
* When in StrictMode, React may double render, so that case is not checked for an exact match.
*/
function checkRenderLog(log: string[], expected: readonly string[]): void {
if (reactStrictMode) {
assert.deepEqual(new Set(log), new Set(expected));
} else {
assert.deepEqual(log, expected);
}
log.length = 0;
}
describe(`StrictMode: ${reactStrictMode}`, () => {
it("usePropTreeNode", () => {
const builder = new SchemaFactory("tree-react-api");
class Point extends builder.object("Point", {
x: builder.number,
y: builder.number,
}) {}
const log: string[] = [];
function PointComponent(props: { node: PropTreeNode }): JSX.Element {
log.push("render");
const { x, y } = usePropTreeNode(props.node, (node) => {
log.push(`usePropTreeNode`);
return {
x: node.x,
y: node.y,
};
});
return {`x: ${x}, y: ${y}`};
}
function ParentComponent(props: { node: PropTreeNode }): JSX.Element {
log.push("parent");
return ;
}
const point = new Point({ x: 1, y: 1 });
const propPoint = toPropTreeNode(point);
const content = ;
const rendered = render(content, { reactStrictMode });
assert.equal(rendered.baseElement.textContent, "x: 1, y: 1");
checkRenderLog(log, ["parent", "render", "usePropTreeNode"]);
rendered.rerender(content);
assertLogEmpty(log);
point.x = 2;
assertLogEmpty(log);
rendered.rerender(content);
// Parent which passed node down did not rerender, but PointComponent which read from it did:
checkRenderLog(log, ["render", "usePropTreeNode"]);
assert.equal(rendered.baseElement.textContent, "x: 2, y: 1");
});
});
describe("withTreeObservations and array", () => {
const builder = new SchemaFactory("tree-react-api");
class Item extends builder.object("Item", {
x: SchemaFactory.number,
}) {}
class Collection extends builder.array("Collection", Item) {}
beforeEach(() => {
// Ensure the log starts empty for each test.
log.length = 0;
});
const log: string[] = [];
const ItemComponent = withMemoizedTreeObservations(
(props: { item: Item }): JSX.Element => {
log.push(`Item: ${props.item.x}`);
return {`${props.item.x}`};
},
{ onInvalidation: () => log.push("Item invalidated") },
);
const CollectionComponent = withTreeObservations(
(props: { collection: Collection }): JSX.Element => {
log.push("Collection");
const items = props.collection.map((item) => (
));
return
{items}
;
},
{ onInvalidation: () => log.push("Collection invalidated") },
);
const ParentComponent = withTreeObservations(
(props: { node: Collection }): JSX.Element => {
log.push("Parent");
return ;
},
{ onInvalidation: () => log.push("Parent invalidated") },
);
it("empty", () => {
const collection = new Collection([]);
const content = ;
render(content, { reactStrictMode });
checkRenderLog(log, ["Parent", "Collection"]);
});
// This confirms that modifying an array does not needlessly invalid parents and reuses children (if they use memo)
it("array editing: insertion", () => {
const collection = new Collection([{ x: 1 }, { x: 2 }, { x: 3 }]);
const content = ;
const rendered = render(content, { reactStrictMode });
checkRenderLog(log, ["Parent", "Collection", "Item: 1", "Item: 2", "Item: 3"]);
collection.insertAtEnd(new Item({ x: 4 }));
checkRenderLog(log, ["Collection invalidated"]);
rendered.rerender(content);
checkRenderLog(log, ["Collection", "Item: 4"]);
assert.equal(rendered.baseElement.textContent, "1234");
});
// This confirms the same as the above, but testes some harder cases.
// For example this one depends on stable keys to reusing children due to indexes changing.
it("array editing: general", () => {
const collection = new Collection([{ x: 1 }, { x: 2 }, { x: 3 }]);
const content = ;
const rendered = render(content, { reactStrictMode });
checkRenderLog(log, ["Parent", "Collection", "Item: 1", "Item: 2", "Item: 3"]);
collection.moveToEnd(0);
checkRenderLog(log, ["Collection invalidated"]);
rendered.rerender(content);
checkRenderLog(log, ["Collection"]);
collection.removeAt(1);
collection.insertAtStart(new Item({ x: 4 }));
checkRenderLog(log, ["Collection invalidated"]);
rendered.rerender(content);
checkRenderLog(log, ["Collection", "Item: 4"]);
assert.equal(rendered.baseElement.textContent, "421");
});
});
}
});
});
/**
* Assert that an array is empty.
*
* Not inlined because doing so causes TypeScript to infer the array type as never[] afterwards and breaks push.
* Better than asserting length is 0 as this gets a better error message on failure.
*/
function assertLogEmpty(log: string[]): void {
assert.deepEqual(log, []);
}